def create_tree(filename="test_tree.root"):
outfile = TFile(filename, 'recreate')
tree = Tree('test_tree', 'A test tree')
tree.var('var1')
for i in range(100):
tree.fill('var1', i)
tree.tree.Fill()
print 'creating a tree', tree.tree.GetName(),\
tree.tree.GetEntries(), 'entries in',\
outfile.GetName()
outfile.Write()
def create_tree(filename="test_tree.root"):
outfile = TFile(filename, 'recreate')
tree = Tree('test_tree', 'A test tree')
tree.var('var1')
for i in range(100):
tree.fill('var1', i)
tree.tree.Fill()
print 'creating a tree', tree.tree.GetName(),\
tree.tree.GetEntries(), 'entries in',\
outfile.GetName()
outfile.Write()
def test_fill(self):
fi = TFile('tree.root', 'RECREATE')
tr = Tree('test_tree', 'A test tree')
tr.var('a')
tr.var('b')
tr.fill('a', 3)
tr.fill('a', 4)
tr.fill('b', 5)
tr.tree.Fill()
fi.Write()
fi.Close()
def test_fill(self):
fi = TFile('tree.root','RECREATE')
tr = Tree('test_tree', 'A test tree')
tr.var('a')
tr.var('b')
tr.fill('a', 3)
tr.fill('a', 4)
tr.fill('b', 5)
tr.tree.Fill()
fi.Write()
fi.Close()
def test_cwn(self):
fi = TFile('tree2.root','RECREATE')
tr = Tree('test_tree', 'A test tree')
tr.var('nvals', the_type=int)
tr.vector('x', 'nvals', 20)
tr.fill('nvals', 10)
tr.vfill('x', range(10))
tr.tree.Fill()
tr.reset()
tr.fill('nvals', 5)
tr.vfill('x', range(5))
tr.tree.Fill()
fi.Write()
fi.Close()
class SimpleTreeProducer(Analyzer):
def beginLoop(self, setup):
super(SimpleTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'simple_tree.root']),
'recreate')
self.tree = Tree(self.cfg_ana.tree_name, self.cfg_ana.tree_title)
self.tree.var('test_variable')
def process(self, event):
self.tree.fill('test_variable', event.input.var1)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
def create_tree(filename=FNAME):
if os.path.isfile(filename):
return filename
outfile = TFile(filename, 'recreate')
tree = Tree('test_tree', 'A test tree')
tree.var('var1')
for i in range(200):
tree.fill('var1', i)
tree.tree.Fill()
# print 'creating a tree', tree.tree.GetName(),\
# tree.tree.GetEntries(), 'entries in',\
# outfile.GetName()
outfile.Write()
outfile.Close()
return outfile.GetName()
class HTo4lGenTreeProducer(Analyzer):
def beginLoop(self, setup):
super(HTo4lGenTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'tree.root']),
'recreate')
self.tree = Tree( 'events', '')
self.tree.var('weight', float)
bookParticle(self.tree, 'lep1vsPt')
bookParticle(self.tree, 'lep2vsPt')
bookParticle(self.tree, 'lep3vsPt')
bookParticle(self.tree, 'lep4vsPt')
bookParticle(self.tree, 'lep1vsEta')
bookParticle(self.tree, 'lep2vsEta')
bookParticle(self.tree, 'lep3vsEta')
bookParticle(self.tree, 'lep4vsEta')
def process(self, event):
self.tree.reset()
gen_leptons = getattr(event, self.cfg_ana.leptons)
self.tree.fill('weight' , event.weight )
if len(gen_leptons) >= 4:
gen_leptons.sort(key=lambda x: x.pt(), reverse=True)
fillParticle(self.tree, 'lep1vsPt', gen_leptons[0])
fillParticle(self.tree, 'lep2vsPt', gen_leptons[1])
fillParticle(self.tree, 'lep3vsPt', gen_leptons[2])
fillParticle(self.tree, 'lep4vsPt', gen_leptons[3])
gen_leptons.sort(key=lambda x: abs(x.eta()))
fillParticle(self.tree, 'lep1vsEta', gen_leptons[0])
fillParticle(self.tree, 'lep2vsEta', gen_leptons[1])
fillParticle(self.tree, 'lep3vsEta', gen_leptons[2])
fillParticle(self.tree, 'lep4vsEta', gen_leptons[3])
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
#self.tree.var('met', float)
bookParticle(self.tree, 'higgs')
bookParticle(self.tree, 'zed')
bookParticle(self.tree, 'l1')
bookParticle(self.tree, 'l2')
bookParticle(self.tree, 'a')
bookMet(self.tree, 'met')
def process(self, event):
self.tree.reset()
zeds = getattr(event, self.cfg_ana.zeds)
zeds.sort(key=lambda x: abs(x.m() - 91.))
photons = getattr(event, self.cfg_ana.photons)
photons.sort(key=lambda x: x.pt(), reverse=True)
leptons = []
if len(zeds) > 0 and len(photons) > 0:
higgs = Resonance(zeds[0], photons[0], 25)
self.tree.fill('weight', event.weight)
# Reco Higgs
fillParticle(self.tree, 'higgs', higgs)
fillParticle(self.tree, 'zed', zeds[0])
fillMet(self.tree, 'met', event.met)
leptons.append(zeds[0].legs[0])
leptons.append(zeds[0].legs[1])
leptons.sort(key=lambda x: x.pt(), reverse=True)
fillLepton(self.tree, 'l1', leptons[0])
fillLepton(self.tree, 'l2', leptons[1])
fillLepton(self.tree, 'a', photons[0])
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class WeightTreeProducer(Analyzer):
def beginLoop(self, setup):
super(WeightTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'weight_tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
def process(self, event):
self.tree.reset()
self.tree.fill('weight', event.weight)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
def create_tree(filename=FNAME, nentries=None):
if not nentries:
if os.path.isfile(filename):
#default number of entries, file exists
return filename
else:
nentries = 200
nentries = int(nentries)
outfile = TFile(filename, 'recreate')
tree = Tree('test_tree', 'A test tree')
tree.var('var1')
for i in range(nentries):
tree.fill('var1', i)
tree.tree.Fill()
outfile.Write()
outfile.Close()
return outfile.GetName()
def create_tree(filename=FNAME, nentries=None):
if not nentries:
if os.path.isfile(filename):
#default number of entries, file exists
return filename
else:
nentries = 200
nentries = int(nentries)
outfile = TFile(filename, 'recreate')
tree = Tree('test_tree', 'A test tree')
tree.var('var1')
for i in range(nentries):
tree.fill('var1', i)
tree.tree.Fill()
outfile.Write()
outfile.Close()
return outfile.GetName()
class HTo4lGenTreeProducer(Analyzer):
def beginLoop(self, setup):
super(HTo4lGenTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
bookParticle(self.tree, 'lep1vsPt')
bookParticle(self.tree, 'lep2vsPt')
bookParticle(self.tree, 'lep3vsPt')
bookParticle(self.tree, 'lep4vsPt')
bookParticle(self.tree, 'lep1vsEta')
bookParticle(self.tree, 'lep2vsEta')
bookParticle(self.tree, 'lep3vsEta')
bookParticle(self.tree, 'lep4vsEta')
def process(self, event):
self.tree.reset()
gen_leptons = getattr(event, self.cfg_ana.leptons)
self.tree.fill('weight', event.weight)
if len(gen_leptons) >= 4:
gen_leptons.sort(key=lambda x: x.pt(), reverse=True)
fillParticle(self.tree, 'lep1vsPt', gen_leptons[0])
fillParticle(self.tree, 'lep2vsPt', gen_leptons[1])
fillParticle(self.tree, 'lep3vsPt', gen_leptons[2])
fillParticle(self.tree, 'lep4vsPt', gen_leptons[3])
gen_leptons.sort(key=lambda x: abs(x.eta()))
fillParticle(self.tree, 'lep1vsEta', gen_leptons[0])
fillParticle(self.tree, 'lep2vsEta', gen_leptons[1])
fillParticle(self.tree, 'lep3vsEta', gen_leptons[2])
fillParticle(self.tree, 'lep4vsEta', gen_leptons[3])
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class SimpleTreeProducer(Analyzer):
def beginLoop(self, setup):
super(SimpleTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'simple_tree.root']),
'recreate')
self.tree = Tree( self.cfg_ana.tree_name,
self.cfg_ana.tree_title )
self.tree.var('test_variable')
def process(self, event):
self.tree.fill('test_variable', event.input.var1)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class SimpleTreeProducer(Analyzer):
'''Test analyzer creating a simple root tree.
Example::
tree = cfg.Analyzer(
SimpleTreeProducer,
tree_name = 'events',
tree_title = 'A simple test tree'
)
The TTree is written to the file C{simple_tree.root} in the analyzer directory.
@param tree_name: Name of the tree (Key in the output root file).
@param tree_title: Title of the tree.
'''
def beginLoop(self, setup):
super(SimpleTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'simple_tree.root']),
'recreate')
self.tree = Tree( self.cfg_ana.tree_name,
self.cfg_ana.tree_title )
self.tree.var('test_variable')
self.tree.var('test_variable_random')
def process(self, event):
'''Process the event.
The input data must contain a variable called "var1",
which is the case of the L{test tree<heppy.utils.debug_tree>}.
The event must contain:
- var_random, which is the case if the L{RandomAnalyzer<heppy.analyzers.examples.simple.RandomAnalyzer.RandomAnalyzer>}
has processed the event.
'''
self.tree.fill('test_variable', event.input.var1)
self.tree.fill('test_variable_random', event.var_random)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class SimpleTreeProducer(Analyzer):
'''Test analyzer creating a simple root tree.
Example::
tree = cfg.Analyzer(
SimpleTreeProducer,
tree_name = 'events',
tree_title = 'A simple test tree'
)
The TTree is written to the file C{simple_tree.root} in the analyzer directory.
@param tree_name: Name of the tree (Key in the output root file).
@param tree_title: Title of the tree.
'''
def beginLoop(self, setup):
super(SimpleTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'simple_tree.root']),
'recreate')
self.tree = Tree( self.cfg_ana.tree_name,
self.cfg_ana.tree_title )
self.tree.var('test_variable')
self.tree.var('test_variable_random')
def process(self, event):
'''Process the event.
The input data must contain a variable called "var1",
which is the case of the L{test tree<heppy.utils.testtree>}.
The event must contain:
- var_random, which is the case if the L{RandomAnalyzer<heppy.analyzers.examples.simple.RandomAnalyzer.RandomAnalyzer>}
has processed the event.
'''
self.tree.fill('test_variable', event.input.var1)
self.tree.fill('test_variable_random', event.var_random)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
def create_tree(filename=FNAME, nentries=None):
'''Create the test tree in file FNAME.'''
if not nentries:
file_good = False
if os.path.isfile(filename):
rfile = TFile(filename)
if not rfile.IsZombie():
file_good = True
if file_good:
return filename
else:
# file needs to be regenerated so setting default
# number of entries
nentries = 200
nentries = int(nentries)
outfile = TFile(filename, 'recreate')
tree = Tree('test_tree', 'A test tree')
tree.var('var1')
for i in range(nentries):
tree.fill('var1', i)
tree.tree.Fill()
outfile.Write()
outfile.Close()
return outfile.GetName()
def create_tree(filename=FNAME, nentries=None):
'''Create the test tree in file FNAME.'''
if not nentries:
file_good = False
if os.path.isfile(filename):
rfile = TFile(filename)
if not rfile.IsZombie():
file_good = True
if file_good:
return filename
else:
# file needs to be regenerated so setting default
# number of entries
nentries = 200
nentries = int(nentries)
outfile = TFile(filename, 'recreate')
tree = Tree('test_tree', 'A test tree')
tree.var('var1')
for i in range(nentries):
tree.fill('var1', i)
tree.tree.Fill()
outfile.Write()
outfile.Close()
return outfile.GetName()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'tree.root']),
'recreate')
self.tree = Tree( 'events', '')
self.tree.var('tau1', float)
self.tree.var('tau2', float)
self.tree.var('tau3', float)
self.tree.var('tau32', float)
self.tree.var('tau31', float)
self.tree.var('tau21', float)
bookParticle(self.tree, 'Jet')
bookParticle(self.tree, 'softDroppedJet')
bookParticle(self.tree, 'leadingSoftDroppedSubJet')
bookParticle(self.tree, 'trailingSoftDroppedSubJet')
def process(self, event):
self.tree.reset()
jets = getattr(event, self.cfg_ana.fatjets)
# store leading (fat) jet observables
if len(jets) > 0 and len(jets[0].subjetsSoftDrop) > 2:
self.tree.fill('tau1' , jets[0].tau1 )
self.tree.fill('tau2' , jets[0].tau2 )
self.tree.fill('tau3' , jets[0].tau3 )
self.tree.fill('tau31' , jets[0].tau3/jets[0].tau1 )
self.tree.fill('tau32' , jets[0].tau3/jets[0].tau2 )
self.tree.fill('tau21' , jets[0].tau2/jets[0].tau1 )
fillParticle(self.tree, 'Jet', jets[0])
# first subjet entry is the cleaned jet itself
fillParticle(self.tree, 'softDroppedJet', jets[0].subjetsSoftDrop[0])
fillParticle(self.tree, 'leadingSoftDroppedSubJet', jets[0].subjetsSoftDrop[1])
fillParticle(self.tree, 'trailingSoftDroppedSubJet', jets[0].subjetsSoftDrop[2])
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'tree.root']),
'recreate')
self.tree = Tree( 'events', '')
self.tree.var('weight', float)
self.tree.var('met', float)
self.tree.var('nljets', float)
self.tree.var('nbjets', float)
self.tree.var('njets', float)
bookParticle(self.tree, 'z')
bookParticle(self.tree, 'l1')
bookParticle(self.tree, 'l2')
bookMet(self.tree, 'met')
def process(self, event):
self.tree.reset()
zeds = getattr(event, self.cfg_ana.zeds)
if len(zeds) == 1:
self.tree.fill('weight' , event.weight )
# Reco Higgs
z = zeds[0]
fillParticle(self.tree, 'z', z)
fillMet(self.tree, 'met', event.met)
fillLepton(self.tree, 'l1', z.legs[0])
fillLepton(self.tree, 'l2', z.legs[1])
self.tree.fill('nbjets' , len(event.selected_bs) )
self.tree.fill('nljets' , len(event.selected_lights) )
self.tree.fill('njets' , len(event.selected_lights) + len(event.selected_bs))
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('nljets', float)
self.tree.var('nbjets', float)
self.tree.var('njets', float)
self.tree.var('DiMuonInvMass', float)
bookParticle(self.tree, 'higgs')
bookParticle(self.tree, 'mu1')
bookParticle(self.tree, 'mu2')
bookMet(self.tree, 'met')
def process(self, event):
self.tree.reset()
higgses = getattr(event, self.cfg_ana.higgses)
if len(higgses) == 1:
self.tree.fill('weight', event.weight)
# Reco Higgs
higgs = higgses[0]
fillParticle(self.tree, 'higgs', higgs)
fillMet(self.tree, 'met', event.met)
fillLepton(self.tree, 'mu1', higgses[0].legs[0])
fillLepton(self.tree, 'mu2', higgses[0].legs[1])
self.tree.fill("DiMuonInvMass", higgses[0]._tlv.M())
self.tree.fill('nbjets', len(event.selected_bs))
self.tree.fill('nljets', len(event.selected_lights))
self.tree.fill('njets',
len(event.selected_lights) + len(event.selected_bs))
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
#self.tree.var('met', float)
self.tree.var('nljets', float)
self.tree.var('nbjets', float)
self.tree.var('njets', float)
bookParticle(self.tree, 'higgs')
bookParticle(self.tree, 'a1')
bookParticle(self.tree, 'a2')
bookMet(self.tree, 'met')
def process(self, event):
self.tree.reset()
higgses = getattr(event, self.cfg_ana.higgses)
higgses.sort(key=lambda x: x.legs[0].pt() + x.legs[1].pt(),
reverse=True)
leptons = []
if len(higgses) > 0:
self.tree.fill('weight', event.weight)
# Reco Higgs
higgs = higgses[0]
fillParticle(self.tree, 'higgs', higgs)
fillMet(self.tree, 'met', event.met)
fillLepton(self.tree, 'a1', higgses[0].legs[0])
fillLepton(self.tree, 'a2', higgses[0].legs[1])
self.tree.fill('nbjets', len(event.selected_bs))
self.tree.fill('nljets', len(event.selected_lights))
self.tree.fill('njets',
len(event.selected_lights) + len(event.selected_bs))
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
#add the Ht variable
self.tree.var('Ht', float)
self.tree.var('rapd', float)
bookParticle(self.tree, 'jet1')
bookParticle(self.tree, 'jet2')
bookParticle(self.tree, 'jet3')
bookMet(self.tree, 'met')
def process(self, event):
self.tree.reset()
self.tree.fill('weight', event.weight)
met = getattr(event, self.cfg_ana.met)
fillMet(self.tree, 'met', met)
# getting the untrimmed jets
jj = getattr(event, 'jets')
# filling Ht
ht = 0
for ijets, j in enumerate(jj):
ht = ht + j.pt()
self.tree.fill('Ht', ht)
jets = getattr(event, self.cfg_ana.jets)
rap = np.absolute(jets[0].eta() - jets[1].eta())
self.tree.fill('rapd', rap)
for ijet, jet in enumerate(jets):
if ijet == 3:
break
fillParticle(self.tree, 'jet{ijet}'.format(ijet=ijet + 1), jet)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class GenTreeProducer(Analyzer):
def beginLoop(self, setup):
super(GenTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('nh', float)
self.tree.var('drhh', float)
bookParticle(self.tree, 'h1')
bookParticle(self.tree, 'h2')
bookParticle(self.tree, 'hh')
def process(self, event):
self.tree.reset()
gen_higgses = getattr(event, self.cfg_ana.gen_higgses)
self.tree.fill('weight', event.weight)
self.tree.fill('nh', len(gen_higgses))
gen_higgses.sort(key=lambda x: x.pt(), reverse=True)
if len(gen_higgses) > 1:
hh = Resonance(gen_higgses[0], gen_higgses[1], 25)
if hh.pt() > 500.:
fillParticle(self.tree, 'h1', gen_higgses[0])
fillParticle(self.tree, 'h2', gen_higgses[1])
fillParticle(self.tree, 'hh', hh)
drhh = deltaR(gen_higgses[0], gen_higgses[1])
self.tree.fill('drhh', drhh)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('nbjets', float)
self.tree.var('weight_0tagex', float)
self.tree.var('weight_1tagex', float)
self.tree.var('weight_2tagex', float)
self.tree.var('weight_3tagex', float)
self.tree.var('weight_4tagex', float)
bookParticle(self.tree, 'l')
bookMet(self.tree, 'met')
# fatjet stuff
for flavour in ['higgs', 'top']:
bookParticle(self.tree, '{}jet'.format(flavour))
bookParticle(self.tree, 'softDropped_{}jet'.format(flavour))
self.tree.var('{}jet_tau1'.format(flavour), float)
self.tree.var('{}jet_tau2'.format(flavour), float)
self.tree.var('{}jet_tau3'.format(flavour), float)
self.tree.var('{}jet_tau32'.format(flavour), float)
self.tree.var('{}jet_tau31'.format(flavour), float)
self.tree.var('{}jet_tau21'.format(flavour), float)
self.tree.var('{}jet_flow15'.format(flavour), float)
self.tree.var('{}jet_flow25'.format(flavour), float)
self.tree.var('{}jet_flow35'.format(flavour), float)
self.tree.var('{}jet_flow45'.format(flavour), float)
self.tree.var('{}jet_flow55'.format(flavour), float)
self.tree.var('{}jet_njs'.format(flavour), float)
self.tree.var('{}jet_nbs'.format(flavour), float)
self.tree.var('{}jet_ncs'.format(flavour), float)
self.tree.var('{}jet_nls'.format(flavour), float)
self.tree.var('{}jet_mjs'.format(flavour), float)
self.tree.var('{}jet_mbs'.format(flavour), float)
##self.tree.var('{}jet_bdt_th'.format(flavour), float)
## for MVA
#self.reader = TMVA.Reader()
#
#self.bdt_tau1 = array.array('f',[0])
#self.bdt_tau2 = array.array('f',[0])
#self.bdt_tau3 = array.array('f',[0])
#self.bdt_tau21 = array.array('f',[0])
#self.bdt_tau31 = array.array('f',[0])
#self.bdt_tau32 = array.array('f',[0])
#self.bdt_flow15 = array.array('f',[0])
#self.bdt_flow25 = array.array('f',[0])
#self.bdt_flow35 = array.array('f',[0])
#self.bdt_flow45 = array.array('f',[0])
#self.bdt_flow55 = array.array('f',[0])
#self.bdt_jet_m = array.array('f',[0])
#self.bdt_softDropped_jet_m = array.array('f',[0])
#self.bdt_jet_nbs = array.array('f',[0])
#self.reader.AddVariable('jet_m', self.bdt_jet_m )
#self.reader.AddVariable('softDropped_jet_m', self.bdt_softDropped_jet_m)
#self.reader.AddVariable('jet_tau1', self.bdt_tau1 )
#self.reader.AddVariable('jet_tau2', self.bdt_tau2 )
#self.reader.AddVariable('jet_tau3', self.bdt_tau3 )
#self.reader.AddVariable('jet_tau32', self.bdt_tau32 )
#self.reader.AddVariable('jet_tau31', self.bdt_tau31 )
#self.reader.AddVariable('jet_tau21', self.bdt_tau21 )
#self.reader.AddVariable('jet_flow15', self.bdt_flow15 )
#self.reader.AddVariable('jet_flow25', self.bdt_flow25 )
#self.reader.AddVariable('jet_flow35', self.bdt_flow35 )
#self.reader.AddVariable('jet_flow45', self.bdt_flow45 )
#self.reader.AddVariable('jet_flow55', self.bdt_flow55 )
#self.reader.AddVariable('jet_nbs', self.bdt_jet_nbs )
#
##path = "/afs/cern.ch/work/s/selvaggi/private/FCCSW/heppy/FCChhAnalyses/tth_boosted/"
#path = "/eos/experiment/fcc/hh/analyses/Higgs/ttH/BDT/"
#self.reader.BookMVA("BDT",str(path)+"BDT_BDT_Higgs_vs_Top.weights.xml")
def process(self, event):
self.tree.reset()
gen_bs = getattr(event, self.cfg_ana.gen_bs)
gen_higgses = getattr(event, self.cfg_ana.gen_higgses)
gen_higgses.sort(key=lambda x: x.pt(), reverse=True)
gen_tops = getattr(event, self.cfg_ana.gen_tops)
gen_tops.sort(key=lambda x: x.pt(), reverse=True)
fatjets = getattr(event, self.cfg_ana.fatjets)
leptons = getattr(event, self.cfg_ana.selected_leptons)
bjets = event.selected_bs
for_jets = event.jets_nolepton
jets = event.jets_30
#_________________________________________________________________
# compute eflow, tau_ij and bdt variables
R = 1.5
use_DELPHES = False
jet_forTRF = []
jetin_forTRF = []
# fill jet collection to compute TRF -> use all jets
for j in for_jets:
ipdg = 0
if use_DELPHES == True:
ipdg = j.tags['flav']
if ipdg != 4 and ipdg != 5: ipdg = 0
else:
ipdg = j.flavour
jet_forTRF.append([j, ipdg])
for jet in fatjets:
setattr(jet, 'njs', 0)
setattr(jet, 'nbs', 0)
setattr(jet, 'ncs', 0)
setattr(jet, 'nls', 0)
setattr(jet, 'flow', [0] * 5)
setattr(jet, 'p4_js', TLorentzVector())
setattr(jet, 'p4_bs', TLorentzVector())
setattr(jet, 'tau32', -9.)
setattr(jet, 'tau31', -9.)
setattr(jet, 'tau21', -9.)
#setattr(jet, 'bdt_th', -99.)
if (jet.tau1 != 0.0):
jet.tau31 = jet.tau3 / jet.tau1
jet.tau21 = jet.tau2 / jet.tau1
if (jet.tau2 != 0.0):
jet.tau32 = jet.tau3 / jet.tau2
# counting the number of jets inside (R = 1.5 - 0.4 = 1.1) fatjet
for j in for_jets:
# fill different jets matched with fatjet
drjjet = deltaR(j, jet)
if drjjet < 1.1:
jet.njs += 1
jet.p4_js += j.p4()
# get pdgID to compute TRF
ipdg = 0
if use_DELPHES == True:
ipdg = j.tags['flav']
if ipdg != 4 and ipdg != 5: ipdg = 0
else:
ipdg = j.flavour
if ipdg == 5:
jet.nbs += 1
jet.p4_bs += j.p4()
elif ipdg == 4:
jet.ncs += 1
else:
jet.nls += 1
# do eflow with constituents here
constituent_vector = TLorentzVector()
#print jet.pt, jet.flow
for n in range(1, 5 + 1):
#print n
for constituent in jet.jetConstituents[1:]:
#print constituent.pt()
dR = jet.p4().DeltaR(constituent.p4())
if ((dR >= (n - 1) / 5. * R) and (dR < n / 5. * R)):
#print 'in ring', dR
jet.flow[n -
1] += abs(constituent.pt()) / abs(jet.pt())
#print jet.flow
## do what is needed to evaluate bdt here
#self.bdt_tau1 [0] = jet.tau1
#self.bdt_tau2 [0] = jet.tau2
#self.bdt_tau3 [0] = jet.tau3
#self.bdt_tau31 [0] = jet.tau31
#self.bdt_tau21 [0] = jet.tau21
#self.bdt_tau32 [0] = jet.tau32
#self.bdt_flow15 [0] = jet.flow[0]
#self.bdt_flow25 [0] = jet.flow[1]
#self.bdt_flow35 [0] = jet.flow[2]
#self.bdt_flow45 [0] = jet.flow[3]
#self.bdt_flow55 [0] = jet.flow[4]
#self.bdt_jet_m [0] = jet.p4().M()
#self.bdt_softDropped_jet_m [0] = jet.subjetsSoftDrop[0].p4().M()
#self.bdt_jet_nbs [0] = float(jet.nbs)
#
#jet.bdt_th = self.reader.EvaluateMVA("BDT")
# highest bdt score is more higgs like
#fatjets.sort(key=lambda x: x.bdt_th, reverse = True)
# 1/ highest number of jets in fatjet is more top like
fatjets.sort(key=lambda x: x.njs, reverse=True)
# 2/ lowest mass is more higgs like
if len(fatjets) > 1 and fatjets[0].njs == fatjets[1].njs:
fatjets.sort(key=lambda x: x.subjetsSoftDrop[0].p4().M(),
reverse=True)
if len(leptons) > 0 and len(fatjets) > 1:
self.tree.fill('weight', event.weight)
fillLepton(self.tree, 'l', leptons[0])
fillMet(self.tree, 'met', event.met)
self.tree.fill('nbjets', len(bjets))
# compute and fill TRF
self.tree.fill('weight_0tagex', getNbTagEx(0, jet_forTRF, -1))
self.tree.fill('weight_1tagex', getNbTagEx(1, jet_forTRF, -1))
self.tree.fill('weight_2tagex', getNbTagEx(2, jet_forTRF, -1))
self.tree.fill('weight_3tagex', getNbTagEx(3, jet_forTRF, -1))
self.tree.fill('weight_4tagex', getNbTagEx(4, jet_forTRF, -1))
'''higgsjet = fatjets[1]
if higgsjet.nbs > 1:
print higgsjet.p4_bs.M(), higgsjet.subjetsSoftDrop[0].p4().M()'''
for flavour in ['higgs', 'top']:
if flavour == 'higgs':
jet = fatjets[1]
else:
jet = fatjets[0]
fillParticle(self.tree, '{}jet'.format(flavour), jet)
fillParticle(self.tree, 'softDropped_{}jet'.format(flavour),
jet.subjetsSoftDrop[0])
self.tree.fill('{}jet_tau1'.format(flavour), jet.tau1)
self.tree.fill('{}jet_tau2'.format(flavour), jet.tau2)
self.tree.fill('{}jet_tau3'.format(flavour), jet.tau3)
self.tree.fill('{}jet_tau31'.format(flavour), jet.tau31)
self.tree.fill('{}jet_tau32'.format(flavour), jet.tau32)
self.tree.fill('{}jet_tau21'.format(flavour), jet.tau21)
#print 'filling: ',jet.flow[0], jet.flow[1], jet.flow[2], jet.flow[3], jet.flow[4]
self.tree.fill('{}jet_flow15'.format(flavour), jet.flow[0])
self.tree.fill('{}jet_flow25'.format(flavour), jet.flow[1])
self.tree.fill('{}jet_flow35'.format(flavour), jet.flow[2])
self.tree.fill('{}jet_flow45'.format(flavour), jet.flow[3])
self.tree.fill('{}jet_flow55'.format(flavour), jet.flow[4])
self.tree.fill('{}jet_njs'.format(flavour), jet.njs)
self.tree.fill('{}jet_nbs'.format(flavour), jet.nbs)
self.tree.fill('{}jet_ncs'.format(flavour), jet.ncs)
self.tree.fill('{}jet_nls'.format(flavour), jet.nls)
self.tree.fill('{}jet_mjs'.format(flavour), jet.p4_js.M())
self.tree.fill('{}jet_mbs'.format(flavour), jet.p4_bs.M())
##self.tree.fill('{}jet_bdt_th'.format(flavour), jet.bdt_th)
#Hjet = fatjets[1]
#tjet = fatjets[0]
#isHiggsOK = False
# 1/ 18/31 wrong
#if Hjet.nbs > tjet.nbs : isHiggsOK=True
#elif Hjet.nbs == tjet.nbs and Hjet.subjetsSoftDrop[0].p4().M() < tjet.subjetsSoftDrop[0].p4().M() : isHiggsOK=True
# 2/ 18/31 wrong
#if Hjet.nbs > 1 : # 3/ 14/15 wrong
# if Hjet.bdt_th > tjet.bdt_th : isHiggsOK=True
# if isHiggsOK==True : print "good match Higgs"
# else : print "wrong match Higgs"
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class CheckTreeProducer(Analyzer):
def beginLoop(self, setup):
super(CheckTreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'check_tree.root']),
'recreate')
self.tree = Tree('events', '')
bookParticle(self.tree, 'gen_fcnc_t')
bookParticle(self.tree, 'gen_fcnc_higgs')
bookParticle(self.tree, 'gen_fcnc_u')
bookParticle(self.tree, 'gen_fcnc_b1')
bookParticle(self.tree, 'gen_fcnc_b2')
self.tree.var('delta_R', float)
bookParticle(self.tree, 'gen_sm_t')
def combine_particle(self, reference, candidates):
if len(candidates) < 2: return None, None
reference_e = reference._tlv.E()
reference_m = reference._tlv.M()
delta_m = 9999999
delta_e = 9999999
best_indexes = [0, 1]
for i, candidate_a in enumerate(candidates):
for j, candidate_b in enumerate(candidates):
if i >= j: continue
candidate_v = candidate_a._tlv + candidate_b._tlv
if abs(reference_m - candidate_v.M()) > delta_m: continue
if abs(reference_e - candidate_v.E()) > delta_e: continue
delta_m = abs(reference_m - candidate_v.M())
delta_e = abs(reference_e - candidate_v.E())
best_indexes = [i, j]
return candidates[best_indexes[0]], candidates[best_indexes[1]]
def combine_particle_ref(self, reference_candidates, fixed_candidate,
candidates):
delta_m = 9999999
delta_e = 9999999
best_indexes = [0, 0]
for i, reference_candidate in enumerate(reference_candidates):
for j, candidate in enumerate(candidates):
candidate_v = fixed_candidate._tlv + candidate._tlv
#print " ~~~~ "
#candidate_v.Print()
#print " + "
#fixed_candidate._tlv.Print()
#print " = "
#reference_candidate._tlv.Print()
#print " ~~~~ "
if abs(reference_candidate._tlv.M() -
candidate_v.M()) > delta_m:
continue
if abs(reference_candidate._tlv.E() -
candidate_v.E()) > delta_e:
continue
delta_m = abs(reference_candidate._tlv.M() - candidate_v.M())
delta_e = abs(reference_candidate._tlv.E() - candidate_v.E())
best_indexes = [i, j]
#print "!Q!!"
return reference_candidates[best_indexes[0]], candidates[
best_indexes[1]]
def combine_opposite(self, reference, candidates):
delta_phi = 0
best_index = 0
for i, candidate in enumerate(candidates):
if reference is candidate: continue
if reference._tlv.DeltaPhi(candidate._tlv) < delta_phi: continue
best_index = i
delta_phi = reference._tlv.DeltaPhi(candidate._tlv)
return candidates[best_index]
def process(self, event):
self.tree.reset()
gen_particles = getattr(event, self.cfg_ana.gen_particles)
gen_hs = [
genParticle for genParticle in gen_particles
if genParticle._pid == 25 and genParticle._status == 22
]
gen_us = [
genParticle for genParticle in gen_particles
if abs(genParticle._pid) == 2
] # and genParticle._status == 23]
gen_bs = [
genParticle for genParticle in gen_particles
if abs(genParticle._pid) == 5
] # and genParticle._status == 23]
gen_ts = [
genParticle for genParticle in gen_particles
if abs(genParticle._pid) == 6
] # and genParticle._status == 22]
if not len(gen_hs): return
if not len(gen_us): return
if not len(gen_ts): return
if not len(gen_bs): return
#for particle in gen_ts + gen_hs + gen_us + gen_bs:
# print particle
#print "===================="
gen_higgs = gen_hs[0] # always a one
fcnc_h_b1, fcnc_h_b2 = self.combine_particle(gen_higgs, gen_bs)
fcnc_top, fcnc_u = self.combine_particle_ref(gen_ts, gen_higgs, gen_us)
sm_top = self.combine_opposite(fcnc_top, gen_ts)
fillParticle(self.tree, 'gen_fcnc_t', fcnc_top)
fillParticle(self.tree, 'gen_fcnc_higgs', gen_higgs)
fillParticle(self.tree, 'gen_fcnc_u', fcnc_u)
fillParticle(self.tree, 'gen_fcnc_b1', fcnc_h_b1)
fillParticle(self.tree, 'gen_fcnc_b2', fcnc_h_b2)
delta_R = max(fcnc_u._tlv.DeltaR(fcnc_h_b1._tlv),
fcnc_u._tlv.DeltaR(fcnc_h_b2._tlv),
fcnc_h_b1._tlv.DeltaR(fcnc_h_b2._tlv))
self.tree.fill('delta_R', delta_R)
fillParticle(self.tree, 'gen_sm_t', sm_top)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
N_JETS = 20
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
float_vars = []
int_vars = []
self.book_container_jet("pfjets02", 10, True)
# self.book_container_jet("pfjets04")
self.book_container_jet("pfjets08", 5, False)
self.book_container_jet("pfjets04_btag", 8, False)
self.book_container("leptons")
for var in float_vars:
self.tree.var(var, float)
for var in int_vars:
self.tree.var(var, float)
bookMet(self.tree, 'met')
bookParticle(self.tree, 'gen_fcnc_t')
bookParticle(self.tree, 'gen_fcnc_higgs')
bookParticle(self.tree, 'gen_fcnc_u')
bookParticle(self.tree, 'gen_fcnc_b1')
bookParticle(self.tree, 'gen_fcnc_b2')
bookParticle(self.tree, 'gen_sm_t')
self.tree.var('delta_R', float)
def process(self, event):
self.tree.reset()
self.tree.fill('weight', sign(event.weight))
################## GEN PART ################## ################## ################## ################## ##################
gen_particles = getattr(event, self.cfg_ana.gen_particles)
gen_hs, gen_us, gen_bs, gen_ts = [], [], [], []
for genParticle in gen_particles:
if genParticle._pid == 25 and genParticle._status == 22:
gen_hs += [genParticle]
if abs(genParticle._pid) == 2: gen_us += [genParticle]
if abs(genParticle._pid) == 5: gen_bs += [genParticle]
if abs(genParticle._pid) == 6: gen_ts += [genParticle]
fcnc_h_b1, fcnc_h_b2 = None, None
fcnc_top, sm_top, fcnc_u = None, None, None
if len(gen_hs) and len(gen_us) and len(gen_ts) and len(gen_bs):
gen_higgs = gen_hs[0] # always a one
fcnc_h_b1, fcnc_h_b2 = self.combine_particle(gen_higgs, gen_bs)
fcnc_top, fcnc_u = self.combine_particle_ref(
gen_ts, gen_higgs, gen_us)
sm_top = self.combine_opposite(fcnc_top, gen_ts)
fillParticle(self.tree, 'gen_fcnc_t', fcnc_top)
fillParticle(self.tree, 'gen_fcnc_higgs', gen_higgs)
fillParticle(self.tree, 'gen_fcnc_u', fcnc_u)
fillParticle(self.tree, 'gen_fcnc_b1', fcnc_h_b1)
fillParticle(self.tree, 'gen_fcnc_b2', fcnc_h_b2)
delta_R = max(fcnc_u._tlv.DeltaR(fcnc_h_b1._tlv),
fcnc_u._tlv.DeltaR(fcnc_h_b2._tlv),
fcnc_h_b1._tlv.DeltaR(fcnc_h_b2._tlv))
self.tree.fill('delta_R', delta_R)
fillParticle(self.tree, 'gen_sm_t', sm_top)
################## REAL PART ################## ################## ################## ################## ##################
pfjets02 = getattr(event, self.cfg_ana.selected_pfjets02)
pfjets04 = getattr(event, self.cfg_ana.selected_pfjets04)
pfjets08 = getattr(event, self.cfg_ana.selected_pfjets08)
jets_btag = getattr(event, self.cfg_ana.selected_bjets)
jets_collections = [pfjets02, pfjets04, pfjets08]
jets_collections_names = ['pfjets02', 'pfjets04', 'pfjets08']
met = getattr(event, self.cfg_ana.met)
leptons = getattr(event, self.cfg_ana.leptons)
################## FILL PART ##################
fillMet(self.tree, 'met', met)
self.fill_container_jet(pfjets02, "pfjets02", 10, True)
#self.fill_container_jet(pfjets04, "pfjets04", )
self.fill_container_jet(pfjets08, "pfjets08", 5, False)
self.fill_container_jet(jets_btag, "pfjets04_btag", 8, False)
self.fill_container(leptons, "leptons")
self.tree.tree.Fill()
############################################################################ HELP FUNCTIONS ###########################################
def book_container_jet(self, name, size=10, container_only=False):
self.book_container(name)
if container_only: return
for i in xrange(size):
nname = name + "_" + str(i)
self.tree.var(nname + '_tau1', float)
self.tree.var(nname + '_tau2', float)
self.tree.var(nname + '_tau3', float)
self.tree.var(nname + '_subjetsSoftDrop_size')
bookParticle(self.tree, nname + "_softDroppedJet")
bookParticle(self.tree, nname + "_leadingSoftDroppedSubJet")
bookParticle(self.tree, nname + "_trailingSoftDroppedSubJet")
def fill_container_jet(self,
container,
name,
size=10,
container_only=False):
self.fill_container(container, name)
if container_only: return
for i in xrange(size):
if i >= len(container): return
nname = name + "_" + str(i)
jet = container[i]
self.tree.fill(nname + '_tau1', jet.tau1)
self.tree.fill(nname + '_tau2', jet.tau2)
self.tree.fill(nname + '_tau3', jet.tau3)
self.tree.fill(nname + '_subjetsSoftDrop_size',
len(jet.subjetsSoftDrop))
if len(jet.subjetsSoftDrop) > 0:
fillParticle(self.tree, nname + "_softDroppedJet",
jet.subjetsSoftDrop[0])
if len(jet.subjetsSoftDrop) > 1:
fillParticle(self.tree, nname + "_leadingSoftDroppedSubJet",
jet.subjetsSoftDrop[1])
if len(jet.subjetsSoftDrop) > 2:
fillParticle(self.tree, nname + "_trailingSoftDroppedSubJet",
jet.subjetsSoftDrop[2])
def book_container(self, name):
self.tree.var(name + "_N", float)
for i in xrange(10):
self.book_tlv(name + "_" + str(i))
def fill_container(self, container, name):
self.tree.fill(name + "_N", len(container))
for i in xrange(10):
if i >= len(container): return
self.fill_tlv(name + "_" + str(i), container[i]._tlv)
def book_tlv(self, name):
self.tree.var(name + "_pt", float)
self.tree.var(name + "_eta", float)
self.tree.var(name + "_phi", float)
self.tree.var(name + "_e", float)
self.tree.var(name + "_m", float)
def fill_tlv(self, name, tlv):
self.tree.fill(name + "_pt", tlv.Pt())
self.tree.fill(name + "_eta", tlv.Eta())
self.tree.fill(name + "_phi", tlv.Phi())
self.tree.fill(name + "_e", tlv.E())
self.tree.fill(name + "_m", tlv.M())
def jet_top_mass_candidate(jets):
# best top mass
best_top_mass_jet = None
second_top_mass_jet = None
delta_mass = 9999999
delta_mass_second = 9999999
for jet in jets:
new_delta = abs(jet._tlv.M() - 172.4)
if new_delta < delta_mass:
second_top_mass_jet = best_top_mass_jet
delta_mass_second = delta_mass
best_top_mass_jet = jet
delta_mass = new_delta
elif new_delta < delta_mass_second:
second_top_mass_jet = jet
delta_mass_second = new_delta
return best_top_mass_jet, second_top_mass_jet
def combine_particle(self, reference, candidates):
if len(candidates) < 2: return None, None
reference_e = reference._tlv.E()
reference_m = reference._tlv.M()
delta_m = 9999999
delta_e = 9999999
best_indexes = [0, 1]
for i, candidate_a in enumerate(candidates):
for j, candidate_b in enumerate(candidates):
if i >= j: continue
candidate_v = candidate_a._tlv + candidate_b._tlv
if abs(reference_m - candidate_v.M()) > delta_m: continue
if abs(reference_e - candidate_v.E()) > delta_e: continue
delta_m = abs(reference_m - candidate_v.M())
delta_e = abs(reference_e - candidate_v.E())
best_indexes = [i, j]
return candidates[best_indexes[0]], candidates[best_indexes[1]]
def combine_particle_ref(self, reference_candidates, fixed_candidate,
candidates):
delta_m = 9999999
delta_e = 9999999
best_indexes = [0, 0]
for i, reference_candidate in enumerate(reference_candidates):
for j, candidate in enumerate(candidates):
candidate_v = fixed_candidate._tlv + candidate._tlv
#print " ~~~~ "
#candidate_v.Print()
#print " + "
#fixed_candidate._tlv.Print()
#print " = "
#reference_candidate._tlv.Print()
#print " ~~~~ "
if abs(reference_candidate._tlv.M() -
candidate_v.M()) > delta_m:
continue
if abs(reference_candidate._tlv.E() -
candidate_v.E()) > delta_e:
continue
delta_m = abs(reference_candidate._tlv.M() - candidate_v.M())
delta_e = abs(reference_candidate._tlv.E() - candidate_v.E())
best_indexes = [i, j]
#print "!Q!!"
return reference_candidates[best_indexes[0]], candidates[
best_indexes[1]]
def combine_opposite(self, reference, candidates):
delta_phi = 0
best_index = 0
for i, candidate in enumerate(candidates):
if reference is candidate: continue
if abs(reference._tlv.DeltaPhi(candidate._tlv)) < delta_phi:
continue
best_index = i
delta_phi = abs(reference._tlv.DeltaPhi(candidate._tlv))
return candidates[best_index]
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'tree.root']),
'recreate')
self.tree = Tree( 'events', '')
self.tree.var('weight', float)
#self.tree.var('met', float)
bookParticle(self.tree, 'higgs')
bookParticle(self.tree, 'zed1')
bookParticle(self.tree, 'zed2')
bookParticle(self.tree, 'l1')
bookParticle(self.tree, 'l2')
bookParticle(self.tree, 'l3')
bookParticle(self.tree, 'l4')
bookMet(self.tree, 'met')
self.tree.var('4mu', int)
self.tree.var('4e', int)
self.tree.var('2mu2e', int)
self.tree.var('nljets', float)
self.tree.var('nbjets', float)
self.tree.var('njets', float)
self.tree.var('nleptons', float)
self.tree.var('nextraleptons', float)
def process(self, event):
self.tree.reset()
zeds = getattr(event, self.cfg_ana.zeds)
zeds.sort(key=lambda x: abs(x.m()-91.))
higgses = getattr(event, self.cfg_ana.higgses)
all_leptons = getattr(event, self.cfg_ana.leptons)
leptons = []
if len(higgses) > 0:
self.tree.fill('weight' , event.weight )
# Reco Higgs
higgs = higgses[0]
fillParticle(self.tree, 'higgs', higgs)
fillParticle(self.tree, 'zed1', zeds[0])
fillParticle(self.tree, 'zed2', zeds[1])
fillMet(self.tree, 'met', event.met)
leptons.append(zeds[0].legs[0])
leptons.append(zeds[0].legs[1])
leptons.append(zeds[1].legs[0])
leptons.append(zeds[1].legs[1])
leptons.sort(key=lambda x: x.pt(), reverse=True)
fillLepton(self.tree, 'l1', leptons[0])
fillLepton(self.tree, 'l2', leptons[1])
fillLepton(self.tree, 'l3', leptons[2])
fillLepton(self.tree, 'l4', leptons[3])
lepton_pdgs = set([abs(l.pdgid()) for l in leptons])
self.tree.fill("4mu", lepton_pdgs == set([13]))
self.tree.fill("4e", lepton_pdgs == set([11]))
self.tree.fill("2mu2e", lepton_pdgs == set([11, 13]))
self.tree.fill('nleptons' , len(all_leptons) )
self.tree.fill('nextraleptons' , len(event.extra_leptons))
self.tree.fill('nbjets' , len(event.selected_bs) )
self.tree.fill('nljets' , len(event.selected_lights) )
self.tree.fill('njets' , len(event.selected_lights) + len(event.selected_bs))
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('weight_1tagex', float)
self.tree.var('weight_2tagex', float)
self.tree.var('weight_1tagin', float)
bookParticle(self.tree, 'Jet1_pf04')
bookParticle(self.tree, 'Jet2_pf04')
self.tree.var('Mj1j2_pf04', float)
self.tree.var('Mj1j2_pf04_METCor', float)
self.tree.var('mt', float)
self.tree.var('mr', float)
self.tree.var('mr2', float)
self.tree.var('mr3', float)
self.tree.var('dr', float)
self.tree.var('dphi', float)
self.tree.var('dphi_met', float)
self.tree.var('ntau', int)
bookMet(self.tree, 'met')
def corrMET(self, jet1, pdg1, jet2, pdg2, met):
metp4 = ROOT.TLorentzVector()
px = met.p4().Px()
py = met.p4().Py()
if (jet1.p4().Pt() > jet2.p4().Pt()):
pz = jet2.p4().Pz() / 2.
e = math.sqrt(px**2 + py**2 + pz**2)
metp4.SetPxPyPzE(px, py, pz, e)
jetcorr2 = Particle(pdg1, 0, jet1.p4() + metp4, 1)
jetcorr1 = Particle(pdg2, 0, jet2.p4(), 1)
else:
pz = jet2.p4().Pz() / 2.
e = math.sqrt(px**2 + py**2 + pz**2)
metp4.SetPxPyPzE(px, py, pz, e)
jetcorr2 = Particle(pdg1, 0, jet1.p4(), 1)
jetcorr1 = Particle(pdg2, 0, jet2.p4() + metp4, 1)
return jetcorr1, jetcorr2
def fillMass(self, jet1, jet2):
mj1j2 = ROOT.TLorentzVector()
j1 = ROOT.TLorentzVector()
j2 = ROOT.TLorentzVector()
j1.SetPtEtaPhiE(jet1.pt(), jet1.eta(), jet1.phi(), jet1.e())
j2.SetPtEtaPhiE(jet2.pt(), jet2.eta(), jet2.phi(), jet2.e())
mj1j2 = j1 + j2
return mj1j2.M()
def process(self, event):
self.tree.reset()
jets_pf04 = getattr(event, self.cfg_ana.jets_pf04_trf)
ntau = 0
for j in jets_pf04:
if j.tags['tauf'] > 0: ntau += 1
self.tree.fill('ntau', ntau)
if len(jets_pf04) < 2: return
weight_1tagex = getOneTagEx(jets_pf04[0], jets_pf04[1])
weight_2tagex = getTwoTagEx(jets_pf04[0], jets_pf04[1])
weight_1tagin = weight_1tagex + weight_2tagex
self.tree.fill('weight_1tagex', weight_1tagex)
self.tree.fill('weight_2tagex', weight_2tagex)
self.tree.fill('weight_1tagin', weight_1tagin)
#print '1tagex: ',weight_1tagex,' 2tagex: ',weight_2tagex,' 1tagin: ',weight_1tagin
mtautau = self.fillMass(jets_pf04[0], jets_pf04[1])
self.tree.fill('Mj1j2_pf04', mtautau)
jetmet1, jetmet2 = self.corrMET(jets_pf04[0], 15, jets_pf04[1], 15,
event.met)
mtautau_metcor = self.fillMass(jetmet1, jetmet2)
self.tree.fill('Mj1j2_pf04_METCor', mtautau_metcor)
Zprime = ROOT.TLorentzVector()
j1 = ROOT.TLorentzVector()
j2 = ROOT.TLorentzVector()
j1.SetPtEtaPhiE(jets_pf04[0].pt(), jets_pf04[0].eta(),
jets_pf04[0].phi(), jets_pf04[0].e())
j2.SetPtEtaPhiE(jets_pf04[1].pt(), jets_pf04[1].eta(),
jets_pf04[1].phi(), jets_pf04[1].e())
Zprime = j1 + j2
Zppx = Zprime.Pt() * math.cos(Zprime.Phi())
Zppy = Zprime.Pt() * math.sin(Zprime.Phi())
metx = event.met.pt() * math.cos(event.met.phi())
mety = event.met.pt() * math.sin(event.met.phi())
ptZp = math.sqrt((Zppx + metx)**2 + (Zppy + mety)**2)
dphi_ll = TVector2.Phi_mpi_pi(j1.Phi() - j2.Phi())
dphi_llmet = TVector2.Phi_mpi_pi(Zprime.Phi() - event.met.phi())
self.tree.fill('dphi', dphi_ll)
self.tree.fill('dphi_met', dphi_llmet)
mt = math.sqrt(2 * Zprime.Pt() * event.met.pt() *
(1 - math.cos(dphi_llmet)))
mll = Zprime.M()
ptll = Zprime.Pt()
met = event.met.pt()
met_d_ptll = metx * Zppx + mety * Zppy
mr = math.sqrt((mtautau**2 - met_d_ptll + math.sqrt(
(mtautau**2 + ptll**2) * (mll**2 + met**2))))
pl1 = ROOT.TLorentzVector()
pl2 = ROOT.TLorentzVector()
pMet = ROOT.TVector3()
pl1.SetPtEtaPhiM(jets_pf04[0].pt(), jets_pf04[0].eta(),
jets_pf04[0].phi(), jets_pf04[0].m())
pl2.SetPtEtaPhiM(jets_pf04[1].pt(), jets_pf04[1].eta(),
jets_pf04[1].phi(), jets_pf04[1].m())
pMet.SetPtEtaPhi(event.met.pt(), 0.0, event.met.phi())
def calcMR(L1, L2):
E = L1.P() + L2.P()
Pz = L1.Pz() + L2.Pz()
MR = math.sqrt(E * E - Pz * Pz)
return MR
def calcMRNEW(L1, L2, M):
vI = M + L1.Vect() + L2.Vect()
vI.SetZ(0.0)
PpQ = calcMR(L1, L2)
vptx = (L1 + L2).Px()
vpty = (L1 + L2).Py()
vpt = ROOT.TVector3()
vpt.SetXYZ(vptx, vpty, 0.0)
MR2 = 0.5 * (PpQ * PpQ - vpt.Dot(vI) + PpQ *
math.sqrt(PpQ * PpQ + vI.Dot(vI) - 2. * vI.Dot(vpt)))
return MR2
mr3 = 2 * math.sqrt(calcMRNEW(pl1, pl2, pMet))
mr2 = calcMR(pl1, pl2)
self.tree.fill('mt', mt)
self.tree.fill('mr', mr)
self.tree.fill('mr2', mr2)
self.tree.fill('mr3', mr3)
self.tree.fill('dr', pl1.DeltaR(pl2))
fillParticle(self.tree, 'Jet1_pf04', jets_pf04[0])
fillParticle(self.tree, 'Jet2_pf04', jets_pf04[1])
self.tree.fill('weight', sign(event.weight))
met = getattr(event, self.cfg_ana.met)
fillMet(self.tree, 'met', met)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class Bs2TauTauAnalyzer(Analyzer):
def beginLoop(self, setup):
self.start_time = time.time()
self.last_timestamp = time.time()
self.counter = 0 # Total number of processed decays
self.pb_counter = 0 # Number of events with B momentum > 25 GeV
gROOT.ProcessLine('.x ' + self.cfg_ana.stylepath) # nice looking plots
# histograms to visualize cuts
self.pb_hist = TH1F('pb_hist', 'P_{B}', 500, 0, 50)
super(Bs2TauTauAnalyzer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'output.root']), 'recreate')
# tree to store MC truth values and its branches
self.mc_truth_tree = Tree(self.cfg_ana.mc_truth_tree_name, self.cfg_ana.mc_truth_tree_title)
self.mc_truth_tree.var('n_particles')
self.mc_truth_tree.var('event_number')
self.mc_truth_tree.var('pv_x')
self.mc_truth_tree.var('pv_y')
self.mc_truth_tree.var('pv_z')
self.mc_truth_tree.var('tv_tauplus_x')
self.mc_truth_tree.var('tv_tauplus_y')
self.mc_truth_tree.var('tv_tauplus_z')
self.mc_truth_tree.var('tv_tauminus_x')
self.mc_truth_tree.var('tv_tauminus_y')
self.mc_truth_tree.var('tv_tauminus_z')
self.mc_truth_tree.var('b_px')
self.mc_truth_tree.var('b_py')
self.mc_truth_tree.var('b_pz')
self.mc_truth_tree.var('opposite_b_quark_mc_truth_px')
self.mc_truth_tree.var('opposite_b_quark_mc_truth_py')
self.mc_truth_tree.var('opposite_b_quark_mc_truth_pz')
self.mc_truth_tree.var('tauplus_px')
self.mc_truth_tree.var('tauplus_py')
self.mc_truth_tree.var('tauplus_pz')
self.mc_truth_tree.var('pi1_tauplus_px')
self.mc_truth_tree.var('pi1_tauplus_py')
self.mc_truth_tree.var('pi1_tauplus_pz')
self.mc_truth_tree.var('pi1_tauplus_q')
self.mc_truth_tree.var('pi2_tauplus_px')
self.mc_truth_tree.var('pi2_tauplus_py')
self.mc_truth_tree.var('pi2_tauplus_pz')
self.mc_truth_tree.var('pi2_tauplus_q')
self.mc_truth_tree.var('pi3_tauplus_px')
self.mc_truth_tree.var('pi3_tauplus_py')
self.mc_truth_tree.var('pi3_tauplus_pz')
self.mc_truth_tree.var('pi3_tauplus_q')
self.mc_truth_tree.var('nu_tauplus_px')
self.mc_truth_tree.var('nu_tauplus_py')
self.mc_truth_tree.var('nu_tauplus_pz')
self.mc_truth_tree.var('tauminus_px')
self.mc_truth_tree.var('tauminus_py')
self.mc_truth_tree.var('tauminus_pz')
self.mc_truth_tree.var('pi1_tauminus_px')
self.mc_truth_tree.var('pi1_tauminus_py')
self.mc_truth_tree.var('pi1_tauminus_pz')
self.mc_truth_tree.var('pi1_tauminus_q')
self.mc_truth_tree.var('pi2_tauminus_px')
self.mc_truth_tree.var('pi2_tauminus_py')
self.mc_truth_tree.var('pi2_tauminus_pz')
self.mc_truth_tree.var('pi2_tauminus_q')
self.mc_truth_tree.var('pi3_tauminus_px')
self.mc_truth_tree.var('pi3_tauminus_py')
self.mc_truth_tree.var('pi3_tauminus_pz')
self.mc_truth_tree.var('pi3_tauminus_q')
self.mc_truth_tree.var('nu_tauminus_px')
self.mc_truth_tree.var('nu_tauminus_py')
self.mc_truth_tree.var('nu_tauminus_pz')
# same for smeared values
self.tree = Tree(self.cfg_ana.tree_name, self.cfg_ana.tree_title)
self.tree.var('n_particles')
self.tree.var('event_number')
self.tree.var('pv_x')
self.tree.var('pv_y')
self.tree.var('pv_z')
self.tree.var('tv_tauplus_x')
self.tree.var('tv_tauplus_y')
self.tree.var('tv_tauplus_z')
self.tree.var('tv_tauminus_x')
self.tree.var('tv_tauminus_y')
self.tree.var('tv_tauminus_z')
self.tree.var('pi1_tauplus_px')
self.tree.var('pi1_tauplus_py')
self.tree.var('pi1_tauplus_pz')
self.tree.var('pi1_tauplus_q')
self.tree.var('pi2_tauplus_px')
self.tree.var('pi2_tauplus_py')
self.tree.var('pi2_tauplus_pz')
self.tree.var('pi2_tauplus_q')
self.tree.var('pi3_tauplus_px')
self.tree.var('pi3_tauplus_py')
self.tree.var('pi3_tauplus_pz')
self.tree.var('pi3_tauplus_q')
self.tree.var('pi1_tauminus_px')
self.tree.var('pi1_tauminus_py')
self.tree.var('pi1_tauminus_pz')
self.tree.var('pi1_tauminus_q')
self.tree.var('pi2_tauminus_px')
self.tree.var('pi2_tauminus_py')
self.tree.var('pi2_tauminus_pz')
self.tree.var('pi2_tauminus_q')
self.tree.var('pi3_tauminus_px')
self.tree.var('pi3_tauminus_py')
self.tree.var('pi3_tauminus_pz')
self.tree.var('pi3_tauminus_q')
def process(self, event):
b_mc_truth = None # B0s particle (MC truth)
opposite_b_quark_mc_truth = None # b quark opposite to B0s (MC truth)
tauplus_mc_truth = None # tau+ from B0s decay (MC truth)
tauminus_mc_truth = None # tau- from B0s decay (MC truth)
pi1_tauplus_mc_truth = None # pi from tau+ decay (MC truth)
pi2_tauplus_mc_truth = None # pi from tau+ decay (MC truth)
pi3_tauplus_mc_truth = None # pi from tau+ decay (MC truth)
nu_tauplus_mc_truth = None # nu from tau+ decay (MC truth)
pi1_tauminus_mc_truth = None # pi from tau- decay (MC truth)
pi2_tauminus_mc_truth = None # pi from tau- decay (MC truth)
pi3_tauminus_mc_truth = None # pi from tau- decay (MC truth)
nu_tauminus_mc_truth = None # nu from tau- decay (MC truth)
pv_mc_truth = None # primary vertex (MC truth)
tv_tauplus_mc_truth = None # tau+ decay vertex (MC truth)
tv_tauminus_mc_truth = None # tau- decay vertex (MC truth)
pi1_tauplus = None # pi from tau+ decay
pi2_tauplus = None # pi from tau+ decay
pi3_tauplus = None # pi from tau+ decay
pi1_tauminus = None # pi from tau- decay
pi2_tauminus = None # pi from tau- decay
pi3_tauminus = None # pi from tau- decay
pv = None # primary vertex
tv_tauplus = None # tau+ decay vertex
tv_tauminus = None # tau- decay vertex
pb = 0. # B momentum
store = event.input # This is just a shortcut
event_info = store.get("EventInfo")
particles_info = store.get("GenParticle")
vertices_info = store.get("GenVertex")
event_number = event_info.at(0).Number()
ptcs = list(map(Particle.fromfccptc, particles_info))
n_particles = len(ptcs)
# looking for B
for ptc_gen1 in ptcs:
if abs(ptc_gen1.pdgid) == 531 and ptc_gen1.start_vertex != ptc_gen1.end_vertex: # if B found and it's not an oscillation
self.counter += 1
if self.counter % 100 == 0:
print('Processing decay #{} ({:.1f} decays / s)'.format(self.counter, 100. / (time.time() - self.last_timestamp)))
self.last_timestamp = time.time()
b_mc_truth = ptc_gen1
pb = b_mc_truth.p.absvalue()
if pb > 25.: # select only events with large momentum of the B
self.pb_counter += 1
# looking for opposite b quark. This is a dirty hack. Works only because both PYTHIA/HepMC and PODIO store particles ordered. But IT'S NOT GUARANTEED
index = 0
while opposite_b_quark_mc_truth == None and index < len(ptcs):
if abs(ptcs[index].pdgid) == 5 and numpy.dot([b_mc_truth.p.px, b_mc_truth.p.py, b_mc_truth.p.pz], [ptcs[index].p.px, ptcs[index].p.py, ptcs[index].p.pz]) < 0:
opposite_b_quark_mc_truth = ptcs[index]
index += 1
pv_mc_truth = b_mc_truth.start_vertex
pv = copy.deepcopy(pv_mc_truth)
for ptc_gen2 in ptcs:
# looking for tauplus
if ptc_gen2.pdgid == -15 and ptc_gen2.start_vertex == b_mc_truth.end_vertex:
tauplus_mc_truth = ptc_gen2
tv_tauplus_mc_truth = ptc_gen2.end_vertex
tv_tauplus = copy.deepcopy(tv_tauplus_mc_truth) # copy is needed in order to keep initial vertex properties after smearing
# looking for tauMinus
if ptc_gen2.pdgid == 15 and ptc_gen2.start_vertex == b_mc_truth.end_vertex:
tauminus_mc_truth = ptc_gen2
tv_tauminus_mc_truth = ptc_gen2.end_vertex
tv_tauminus = copy.deepcopy(tv_tauminus_mc_truth) # copy is needed in order to keep initial vertex properties after smearing
# looking for pions and nu from tau+ decay
pis_tauplus_mc_truth = list([])
for ptc_gen3 in ptcs:
if abs(ptc_gen3.pdgid) == 211 and ptc_gen3.start_vertex == tauplus_mc_truth.end_vertex:
pis_tauplus_mc_truth.append(ptc_gen3)
if ptc_gen3.pdgid == 16:
nu_tauplus_mc_truth = ptc_gen3
if len(pis_tauplus_mc_truth) == 3:
pi1_tauplus_mc_truth, pi2_tauplus_mc_truth, pi3_tauplus_mc_truth = pis_tauplus_mc_truth[0], pis_tauplus_mc_truth[1], pis_tauplus_mc_truth[2]
pi1_tauplus, pi2_tauplus, pi3_tauplus = copy.deepcopy(pi1_tauplus_mc_truth), copy.deepcopy(pi2_tauplus_mc_truth), copy.deepcopy(pi3_tauplus_mc_truth)
# looking for pions and nu from tau- decay
pis_tauminus_mc_truth = list([])
for ptc_gen3 in ptcs:
if abs(ptc_gen3.pdgid) == 211 and ptc_gen3.start_vertex == tauminus_mc_truth.end_vertex:
pis_tauminus_mc_truth.append(ptc_gen3)
if ptc_gen3.pdgid == -16:
nu_tauminus_mc_truth = ptc_gen3
if len(pis_tauminus_mc_truth) == 3:
pi1_tauminus_mc_truth, pi2_tauminus_mc_truth, pi3_tauminus_mc_truth = pis_tauminus_mc_truth[0], pis_tauminus_mc_truth[1], pis_tauminus_mc_truth[2]
pi1_tauminus, pi2_tauminus, pi3_tauminus = copy.deepcopy(pi1_tauminus_mc_truth), copy.deepcopy(pi2_tauminus_mc_truth), copy.deepcopy(pi3_tauminus_mc_truth)
# applying smearing
if self.cfg_ana.smear_momentum:
pi1_tauplus.p = smear_momentum(pi1_tauplus.p, self.cfg_ana.momentum_x_resolution, self.cfg_ana.momentum_y_resolution, self.cfg_ana.momentum_z_resolution)
pi2_tauplus.p = smear_momentum(pi2_tauplus.p, self.cfg_ana.momentum_x_resolution, self.cfg_ana.momentum_y_resolution, self.cfg_ana.momentum_z_resolution)
pi3_tauplus.p = smear_momentum(pi3_tauplus.p, self.cfg_ana.momentum_x_resolution, self.cfg_ana.momentum_y_resolution, self.cfg_ana.momentum_z_resolution)
pi1_tauminus.p = smear_momentum(pi1_tauminus.p, self.cfg_ana.momentum_x_resolution, self.cfg_ana.momentum_y_resolution, self.cfg_ana.momentum_z_resolution)
pi2_tauminus.p = smear_momentum(pi2_tauminus.p, self.cfg_ana.momentum_x_resolution, self.cfg_ana.momentum_y_resolution, self.cfg_ana.momentum_z_resolution)
pi3_tauminus.p = smear_momentum(pi3_tauminus.p, self.cfg_ana.momentum_x_resolution, self.cfg_ana.momentum_y_resolution, self.cfg_ana.momentum_z_resolution)
if self.cfg_ana.smear_pv:
pv = smear_vertex(pv, self.cfg_ana.pv_x_resolution, self.cfg_ana.pv_y_resolution, self.cfg_ana.pv_z_resolution)
if self.cfg_ana.smear_tv:
tv_tauplus = smear_vertex(tv_tauplus, self.cfg_ana.tv_x_resolution, self.cfg_ana.tv_y_resolution, self.cfg_ana.tv_z_resolution)
tv_tauminus = smear_vertex(tv_tauminus, self.cfg_ana.tv_x_resolution, self.cfg_ana.tv_y_resolution, self.cfg_ana.tv_z_resolution)
# to keep consistency
pi1_tauplus.start_vertex, pi2_tauplus.start_vertex, pi3_tauplus.start_vertex = tv_tauplus, tv_tauplus, tv_tauplus
pi1_tauminus.start_vertex, pi2_tauminus.start_vertex, pi3_tauminus.start_vertex = tv_tauminus, tv_tauminus, tv_tauminus
if pi1_tauplus.is_valid() and pi2_tauplus.is_valid() and pi3_tauplus.is_valid() and pi1_tauminus.is_valid() and pi2_tauminus.is_valid() and pi3_tauminus.is_valid():
# filling histogram
self.pb_hist.Fill(pb)
# filling MC truth information
self.mc_truth_tree.fill('event_number', event_number)
self.mc_truth_tree.fill('n_particles', n_particles)
self.mc_truth_tree.fill('pv_x', pv_mc_truth.x)
self.mc_truth_tree.fill('pv_y', pv_mc_truth.y)
self.mc_truth_tree.fill('pv_z', pv_mc_truth.z)
self.mc_truth_tree.fill('tv_tauplus_x', tv_tauplus_mc_truth.x)
self.mc_truth_tree.fill('tv_tauplus_y', tv_tauplus_mc_truth.y)
self.mc_truth_tree.fill('tv_tauplus_z', tv_tauplus_mc_truth.z)
self.mc_truth_tree.fill('tv_tauminus_x', tv_tauminus_mc_truth.x)
self.mc_truth_tree.fill('tv_tauminus_y', tv_tauminus_mc_truth.y)
self.mc_truth_tree.fill('tv_tauminus_z', tv_tauminus_mc_truth.z)
self.mc_truth_tree.fill('b_px', b_mc_truth.p.px)
self.mc_truth_tree.fill('b_py', b_mc_truth.p.py)
self.mc_truth_tree.fill('b_pz', b_mc_truth.p.pz)
self.mc_truth_tree.fill('opposite_b_quark_mc_truth_px', opposite_b_quark_mc_truth.p.px)
self.mc_truth_tree.fill('opposite_b_quark_mc_truth_py', opposite_b_quark_mc_truth.p.py)
self.mc_truth_tree.fill('opposite_b_quark_mc_truth_pz', opposite_b_quark_mc_truth.p.pz)
self.mc_truth_tree.fill('tauplus_px', tauplus_mc_truth.p.px)
self.mc_truth_tree.fill('tauplus_py', tauplus_mc_truth.p.py)
self.mc_truth_tree.fill('tauplus_pz', tauplus_mc_truth.p.pz)
self.mc_truth_tree.fill('pi1_tauplus_q', pi1_tauplus_mc_truth.charge)
self.mc_truth_tree.fill('pi1_tauplus_px', pi1_tauplus_mc_truth.p.px)
self.mc_truth_tree.fill('pi1_tauplus_py', pi1_tauplus_mc_truth.p.py)
self.mc_truth_tree.fill('pi1_tauplus_pz', pi1_tauplus_mc_truth.p.pz)
self.mc_truth_tree.fill('pi2_tauplus_q', pi2_tauplus_mc_truth.charge)
self.mc_truth_tree.fill('pi2_tauplus_px', pi2_tauplus_mc_truth.p.px)
self.mc_truth_tree.fill('pi2_tauplus_py', pi2_tauplus_mc_truth.p.py)
self.mc_truth_tree.fill('pi2_tauplus_pz', pi2_tauplus_mc_truth.p.pz)
self.mc_truth_tree.fill('pi3_tauplus_q', pi3_tauplus_mc_truth.charge)
self.mc_truth_tree.fill('pi3_tauplus_px', pi3_tauplus_mc_truth.p.px)
self.mc_truth_tree.fill('pi3_tauplus_py', pi3_tauplus_mc_truth.p.py)
self.mc_truth_tree.fill('pi3_tauplus_pz', pi3_tauplus_mc_truth.p.pz)
self.mc_truth_tree.fill('nu_tauplus_px', nu_tauplus_mc_truth.p.px)
self.mc_truth_tree.fill('nu_tauplus_py', nu_tauplus_mc_truth.p.py)
self.mc_truth_tree.fill('nu_tauplus_pz', nu_tauplus_mc_truth.p.pz)
self.mc_truth_tree.fill('tauminus_px', tauminus_mc_truth.p.px)
self.mc_truth_tree.fill('tauminus_py', tauminus_mc_truth.p.py)
self.mc_truth_tree.fill('tauminus_pz', tauminus_mc_truth.p.pz)
self.mc_truth_tree.fill('pi1_tauminus_q', pi1_tauminus_mc_truth.charge)
self.mc_truth_tree.fill('pi1_tauminus_px', pi1_tauminus_mc_truth.p.px)
self.mc_truth_tree.fill('pi1_tauminus_py', pi1_tauminus_mc_truth.p.py)
self.mc_truth_tree.fill('pi1_tauminus_pz', pi1_tauminus_mc_truth.p.pz)
self.mc_truth_tree.fill('pi2_tauminus_q', pi2_tauminus_mc_truth.charge)
self.mc_truth_tree.fill('pi2_tauminus_px', pi2_tauminus_mc_truth.p.px)
self.mc_truth_tree.fill('pi2_tauminus_py', pi2_tauminus_mc_truth.p.py)
self.mc_truth_tree.fill('pi2_tauminus_pz', pi2_tauminus_mc_truth.p.pz)
self.mc_truth_tree.fill('pi3_tauminus_q', pi3_tauminus_mc_truth.charge)
self.mc_truth_tree.fill('pi3_tauminus_px', pi3_tauminus_mc_truth.p.px)
self.mc_truth_tree.fill('pi3_tauminus_py', pi3_tauminus_mc_truth.p.py)
self.mc_truth_tree.fill('pi3_tauminus_pz', pi3_tauminus_mc_truth.p.pz)
self.mc_truth_tree.fill('nu_tauminus_px', nu_tauminus_mc_truth.p.px)
self.mc_truth_tree.fill('nu_tauminus_py', nu_tauminus_mc_truth.p.py)
self.mc_truth_tree.fill('nu_tauminus_pz', nu_tauminus_mc_truth.p.pz)
self.mc_truth_tree.tree.Fill()
# filling event information
self.tree.fill('event_number', event_number)
self.tree.fill('n_particles', n_particles)
self.tree.fill('pv_x', pv.x)
self.tree.fill('pv_y', pv.y)
self.tree.fill('pv_z', pv.z)
self.tree.fill('tv_tauplus_x', tv_tauplus.x)
self.tree.fill('tv_tauplus_y', tv_tauplus.y)
self.tree.fill('tv_tauplus_z', tv_tauplus.z)
self.tree.fill('tv_tauminus_x', tv_tauminus.x)
self.tree.fill('tv_tauminus_y', tv_tauminus.y)
self.tree.fill('tv_tauminus_z', tv_tauminus.z)
self.tree.fill('pi1_tauplus_q', pi1_tauplus.charge)
self.tree.fill('pi1_tauplus_px', pi1_tauplus.p.px)
self.tree.fill('pi1_tauplus_py', pi1_tauplus.p.py)
self.tree.fill('pi1_tauplus_pz', pi1_tauplus.p.pz)
self.tree.fill('pi2_tauplus_q', pi2_tauplus.charge)
self.tree.fill('pi2_tauplus_px', pi2_tauplus.p.px)
self.tree.fill('pi2_tauplus_py', pi2_tauplus.p.py)
self.tree.fill('pi2_tauplus_pz', pi2_tauplus.p.pz)
self.tree.fill('pi3_tauplus_q', pi3_tauplus.charge)
self.tree.fill('pi3_tauplus_px', pi3_tauplus.p.px)
self.tree.fill('pi3_tauplus_py', pi3_tauplus.p.py)
self.tree.fill('pi3_tauplus_pz', pi3_tauplus.p.pz)
self.tree.fill('pi1_tauminus_q', pi1_tauminus.charge)
self.tree.fill('pi1_tauminus_px', pi1_tauminus.p.px)
self.tree.fill('pi1_tauminus_py', pi1_tauminus.p.py)
self.tree.fill('pi1_tauminus_pz', pi1_tauminus.p.pz)
self.tree.fill('pi2_tauminus_q', pi2_tauminus.charge)
self.tree.fill('pi2_tauminus_px', pi2_tauminus.p.px)
self.tree.fill('pi2_tauminus_py', pi2_tauminus.p.py)
self.tree.fill('pi2_tauminus_pz', pi2_tauminus.p.pz)
self.tree.fill('pi3_tauminus_q', pi3_tauminus.charge)
self.tree.fill('pi3_tauminus_px', pi3_tauminus.p.px)
self.tree.fill('pi3_tauminus_py', pi3_tauminus.p.py)
self.tree.fill('pi3_tauminus_pz', pi3_tauminus.p.pz)
self.tree.tree.Fill()
def write(self, unusefulVar):
self.rootfile.Write()
self.rootfile.Close()
pb_canvas = TCanvas('pb_canvas', 'B momentum', 600, 400)
pb_canvas.cd()
self.pb_hist.Draw()
pb_canvas.Update()
print('Total decays processed: {}'.format(self.counter))
print('Elapsed time: {:.1f} s ({:.1f} decays / s)'.format(time.time() - self.start_time, float(self.counter) / (time.time() - self.start_time)))
print('Efficiency:\n\tMomentum of B cut: {:.3f}'.format (float(self.pb_counter)/float(self.counter)))
raw_input('Press ENTER when finished')
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
bookParticle(self.tree, 'ta1')
self.tree.var('ta1_mt', float)
bookParticle(self.tree, 'ta2')
self.tree.var('ta2_mt', float)
bookParticle(self.tree, 'b1')
bookParticle(self.tree, 'b2')
bookParticle(self.tree, 'j1')
bookParticle(self.tree, 'j2')
bookParticle(self.tree, 'htata')
bookParticle(self.tree, 'htata_metcorr')
bookParticle(self.tree, 'hbb')
bookParticle(self.tree, 'hh')
bookParticle(self.tree, 'hh_metcorr')
self.tree.var('mT2', float)
self.tree.var('sT', float)
self.tree.var('ntajets', float)
self.tree.var('nbjets', float)
self.tree.var('nljets', float)
self.tree.var('njets', float)
self.tree.var('nlep', float)
self.tree.var('drbb', float)
self.tree.var('drtata', float)
bookMet(self.tree, 'met')
self.reader = ROOT.TMVA.Reader()
self.bdt_ta1_pt = array.array('f', [0])
self.bdt_ta1_eta = array.array('f', [0])
self.bdt_ta1_phi = array.array('f', [0])
self.bdt_ta2_pt = array.array('f', [0])
self.bdt_ta2_eta = array.array('f', [0])
self.bdt_ta2_phi = array.array('f', [0])
self.bdt_b1_pt = array.array('f', [0])
self.bdt_b1_eta = array.array('f', [0])
self.bdt_b1_phi = array.array('f', [0])
self.bdt_b2_pt = array.array('f', [0])
self.bdt_b2_eta = array.array('f', [0])
self.bdt_b2_phi = array.array('f', [0])
self.bdt_met_pt = array.array('f', [0])
self.bdt_met_phi = array.array('f', [0])
self.bdt_met_px = array.array('f', [0])
self.bdt_met_py = array.array('f', [0])
self.bdt_htata_pt = array.array('f', [0])
self.bdt_htata_eta = array.array('f', [0])
self.bdt_htata_phi = array.array('f', [0])
self.bdt_htata_m = array.array('f', [0])
self.bdt_hbb_pt = array.array('f', [0])
self.bdt_hbb_eta = array.array('f', [0])
self.bdt_hbb_phi = array.array('f', [0])
self.bdt_hbb_m = array.array('f', [0])
self.bdt_hh_pt = array.array('f', [0])
self.bdt_hh_eta = array.array('f', [0])
self.bdt_hh_phi = array.array('f', [0])
self.bdt_hh_m = array.array('f', [0])
self.bdt_ta1_mt = array.array('f', [0])
self.bdt_ta2_mt = array.array('f', [0])
self.bdt_mT2 = array.array('f', [0])
self.bdt_sT = array.array('f', [0])
self.bdt_njets = array.array('f', [0])
self.bdt_nbjets = array.array('f', [0])
self.bdt_ntajets = array.array('f', [0])
#self.bdt_nlep = array.array('f',[0])
self.reader.AddVariable('ta1_pt', self.bdt_ta1_pt)
self.reader.AddVariable('ta1_eta', self.bdt_ta1_eta)
self.reader.AddVariable('ta1_phi', self.bdt_ta1_phi)
self.reader.AddVariable('ta2_pt', self.bdt_ta2_pt)
self.reader.AddVariable('ta2_eta', self.bdt_ta2_eta)
self.reader.AddVariable('ta2_phi', self.bdt_ta2_phi)
self.reader.AddVariable('b1_pt', self.bdt_b1_pt)
self.reader.AddVariable('b1_eta', self.bdt_b1_eta)
self.reader.AddVariable('b1_phi', self.bdt_b1_phi)
self.reader.AddVariable('b2_pt', self.bdt_b2_pt)
self.reader.AddVariable('b2_eta', self.bdt_b2_eta)
self.reader.AddVariable('b2_phi', self.bdt_b2_phi)
self.reader.AddVariable('met_pt', self.bdt_met_pt)
self.reader.AddVariable('met_phi', self.bdt_met_phi)
self.reader.AddVariable('met_px', self.bdt_met_px)
self.reader.AddVariable('met_py', self.bdt_met_py)
self.reader.AddVariable('htata_pt', self.bdt_htata_pt)
self.reader.AddVariable('htata_eta', self.bdt_htata_eta)
self.reader.AddVariable('htata_phi', self.bdt_htata_phi)
self.reader.AddVariable('htata_m', self.bdt_htata_m)
self.reader.AddVariable('hbb_pt', self.bdt_hbb_pt)
self.reader.AddVariable('hbb_eta', self.bdt_hbb_eta)
self.reader.AddVariable('hbb_phi', self.bdt_hbb_phi)
self.reader.AddVariable('hbb_m', self.bdt_hbb_m)
self.reader.AddVariable('hh_pt', self.bdt_hh_pt)
self.reader.AddVariable('hh_eta', self.bdt_hh_eta)
self.reader.AddVariable('hh_phi', self.bdt_hh_phi)
self.reader.AddVariable('hh_m', self.bdt_hh_m)
self.reader.AddVariable('ta1_mt', self.bdt_ta1_mt)
self.reader.AddVariable('ta2_mt', self.bdt_ta2_mt)
self.reader.AddVariable('mT2', self.bdt_mT2)
self.reader.AddVariable('sT', self.bdt_sT)
self.reader.AddVariable('njets', self.bdt_njets)
self.reader.AddVariable('nbjets', self.bdt_nbjets)
self.reader.AddVariable('ntajets', self.bdt_ntajets)
#self.reader.AddVariable('nlep' , self.bdt_nlep)
#path = "/afs/cern.ch/work/s/selvaggi/private/Analysis/FCC/analysis/TMVAfacility/HH_vs_Top_lowstat/weights/"
path = "/eos/user/s/selvaggi/Analysis/TMVA/hhbbtahtah_v3/lambda100_5f/weights/"
self.reader.BookMVA("BDT", path + "/BDT_BDT_lambda100_5f.weights.xml")
self.tree.var('tmva_bdt', float)
def process(self, event):
self.tree.reset()
htatas = getattr(event, self.cfg_ana.htatas)
hbbs = getattr(event, self.cfg_ana.hbbs)
met = event.met
htatas.sort(key=lambda x: abs(x.m() - 125.))
hbbs.sort(key=lambda x: abs(x.m() - 125.))
bs = event.selected_bs
taus = event.selected_taus
lights = event.selected_lights
leptons = event.selected_leptons
#print '-------------------'
#print len(htatas), len(hbbs)
#print len(taus), len(bs)
#for tau in taus:
# print tau.charge
#print ROOT.return2()
#f = Foo()
#f.bar() #and you will see "Hello" on the screen
'''
mVisA = 10.; # mass of visible object on side A. Must be >=0.
pxA = 20.; # x momentum of visible object on side A.
pyA = 30.; # y momentum of visible object on side A.
mVisB = 10.; # mass of visible object on side B. Must be >=0.
pxB = -20.; # x momentum of visible object on side B.
pyB = -30.; # y momentum of visible object on side B.
pxMiss = -5.; # x component of missing transverse momentum.
pyMiss = -5.; # y component of missing transverse momentum.
chiA = 4.; # hypothesised mass of invisible on side A. Must be >=0.
chiB = 7.; # hypothesised mass of invisible on side B. Must be >=0.
desiredPrecisionOnMt2 = 0.; # Must be >=0. If 0 alg aims for machine precision. if >0, MT2 computed to supplied absolute precision.
useDeciSectionsInitially=True
asymm_mt2 = asymm_mt2_lester_bisect()
print '-----------------------------------------'
MT2 = asymm_mt2.get_mT2(
mVisA, pxA, pyA,
mVisB, pxB, pyB,
pxMiss, pyMiss,
chiA, chiB,
desiredPrecisionOnMt2,
useDeciSectionsInitially)
print 'MT2', MT2
'''
# fully hadronic selection
if len(taus) > 1 and len(bs) > 1 and len(leptons) == 0:
self.tree.fill('weight', event.weight)
#print event.weight
fillParticle(self.tree, 'ta1', taus[0])
fillParticle(self.tree, 'ta2', taus[1])
fillParticle(self.tree, 'b1', bs[0])
fillParticle(self.tree, 'b2', bs[1])
'''
def mTsq(bT, cT, mB, mC):
eB = math.sqrt(mB*mB+ bT*bT)
eC = math.sqrt(mC*mC+ cT*cT)
return mB*mB+mC*mC+2*(eB*eC - bT*cT)
def smT2(bt1, bt2):
return max(math.sqrt(bt1),math.sqrt(bt2))
mTsq1 = mTsq(taus[0].p4().Vect().XYvector(), bs[0].p4().Vect().XYvector(), taus[0].p4().M(), bs[0].p4().M())
mTsq2 = mTsq(taus[1].p4().Vect().XYvector(), bs[1].p4().Vect().XYvector(), taus[1].p4().M(), bs[1].p4().M())
smTsq = smT2(mTsq1, mTsq2)
#print mTsq1, mTsq2, smTsq
'''
mVisA = bs[0].p4().M()
# mass of visible object on side A. Must be >=0.
pxA = bs[0].p4().Px()
# x momentum of visible object on side A.
pyA = bs[0].p4().Py()
# y momentum of visible object on side A.
mVisB = bs[1].p4().M()
# mass of visible object on side A. Must be >=0.
pxB = bs[1].p4().Px()
# x momentum of visible object on side A.
pyB = bs[1].p4().Py()
# y momentum of visible object on side A.
pxMiss = taus[0].p4().Px() + taus[1].p4().Px() + met.p4().Px(
) # x component of missing transverse momentum.
pyMiss = taus[0].p4().Py() + taus[1].p4().Py() + met.p4().Py(
) # x component of missing transverse momentum.
chiA = taus[0].p4().M()
# hypothesised mass of invisible on side A. Must be >=0.
chiB = taus[1].p4().M()
# hypothesised mass of invisible on side B. Must be >=0.
desiredPrecisionOnMt2 = 0.
# Must be >=0. If 0 alg aims for machine precision. if >0, MT2 computed to supplied absolute precision.
useDeciSectionsInitially = True
asymm_mt2 = asymm_mt2_lester_bisect()
MT2 = asymm_mt2.get_mT2(mVisA, pxA, pyA, mVisB, pxB, pyB, pxMiss,
pyMiss, chiA, chiB, desiredPrecisionOnMt2,
useDeciSectionsInitially)
#print 'MT2', MT2
self.tree.fill('mT2', MT2)
if len(lights) > 0:
fillParticle(self.tree, 'j1', lights[0])
if len(lights) > 1:
fillParticle(self.tree, 'j2', lights[1])
def computeMT(taup4, metp4):
scalar_prod = taup4.Px() * metp4.Px() + taup4.Py() * metp4.Py()
return math.sqrt(2 * (taup4.Pt() * metp4.Pt() - scalar_prod))
mt1 = computeMT(taus[0].p4(), met.p4())
mt2 = computeMT(taus[1].p4(), met.p4())
self.tree.fill('ta1_mt', mt1)
self.tree.fill('ta2_mt', mt2)
st = taus[0].p4().Pt() + taus[1].p4().Pt() + bs[0].p4().Pt(
) + bs[0].p4().Pt() + met.p4().Pt()
self.tree.fill('sT', st)
fillMet(self.tree, 'met', met)
fillParticle(self.tree, 'htata', htatas[0])
fillParticle(self.tree, 'hbb', hbbs[0])
htata_metcorr_p4 = taus[0].p4() + taus[1].p4() + met.p4()
htata_metcorr = Particle(25, 0, htata_metcorr_p4, 1)
fillParticle(self.tree, 'htata_metcorr', htata_metcorr)
hh = Resonance(htatas[0], hbbs[0], 25)
hh_metcorr = Resonance(htata_metcorr, hbbs[0], 25)
fillParticle(self.tree, 'hh', hh)
fillParticle(self.tree, 'hh_metcorr', hh_metcorr)
self.tree.fill('nbjets', len(event.selected_bs))
self.tree.fill('nljets', len(event.selected_lights))
self.tree.fill(
'njets',
len(event.selected_lights) + len(event.selected_bs) +
len(event.selected_taus))
self.tree.fill('nlep', len(event.selected_leptons))
self.tree.fill('ntajets', len(event.selected_taus))
drbb = deltaR(bs[0], bs[1])
drtata = deltaR(taus[0], taus[1])
self.tree.fill('drtata', drtata)
self.tree.fill('drbb', drbb)
# here fill all variables for BDT
self.bdt_ta1_pt[0] = taus[0].p4().Pt()
self.bdt_ta1_eta[0] = taus[0].p4().Eta()
self.bdt_ta1_phi[0] = taus[0].p4().Phi()
self.bdt_ta2_pt[0] = taus[1].p4().Pt()
self.bdt_ta2_eta[0] = taus[1].p4().Eta()
self.bdt_ta2_phi[0] = taus[1].p4().Phi()
self.bdt_b1_pt[0] = bs[0].p4().Pt()
self.bdt_b1_eta[0] = bs[0].p4().Eta()
self.bdt_b1_phi[0] = bs[0].p4().Phi()
self.bdt_b2_pt[0] = bs[1].p4().Pt()
self.bdt_b2_eta[0] = bs[1].p4().Eta()
self.bdt_b2_phi[0] = bs[1].p4().Phi()
self.bdt_met_pt[0] = met.p4().Pt()
self.bdt_met_phi[0] = met.p4().Phi()
self.bdt_met_px[0] = met.p4().Px()
self.bdt_met_py[0] = met.p4().Py()
self.bdt_htata_pt[0] = htatas[0].p4().Pt()
self.bdt_htata_eta[0] = htatas[0].p4().Eta()
self.bdt_htata_phi[0] = htatas[0].p4().Phi()
self.bdt_htata_m[0] = htatas[0].p4().M()
self.bdt_hbb_pt[0] = hbbs[0].p4().Pt()
self.bdt_hbb_eta[0] = hbbs[0].p4().Eta()
self.bdt_hbb_phi[0] = hbbs[0].p4().Phi()
self.bdt_hbb_m[0] = hbbs[0].p4().M()
self.bdt_hh_pt[0] = hh.p4().Pt()
self.bdt_hh_eta[0] = hh.p4().Eta()
self.bdt_hh_phi[0] = hh.p4().Phi()
self.bdt_hh_m[0] = hh.p4().M()
self.bdt_ta1_mt[0] = mt1
self.bdt_ta2_mt[0] = mt2
self.bdt_mT2[0] = MT2
self.bdt_sT[0] = st
self.bdt_njets[0] = len(event.selected_lights) + len(
event.selected_bs) + len(event.selected_taus)
self.bdt_nbjets[0] = len(event.selected_bs)
self.bdt_ntajets[0] = len(event.selected_taus)
#self.bdt_nlep [0] = len(event.selected_leptons)
#print MT2, ",", s ,",", len(event.selected_lights) + len(event.selected_bs) + len(event.selected_taus), ",", len(event.selected_bs) ,",", len(event.selected_taus) ,",", len(event.selected_leptons)t
mva_value = self.reader.EvaluateMVA("BDT")
#print mva_value
self.tree.fill('tmva_bdt', mva_value)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'tree.root']),
'recreate')
self.tree = Tree( 'events', '')
self.tree.var('weight', float)
bookParticle(self.tree, 'zprime_ele')
bookParticle(self.tree, 'zprime_muon')
bookParticle(self.tree, 'jet1')
bookParticle(self.tree, 'jet2')
bookParticle(self.tree, 'jet3')
bookLepton(self.tree, 'lep1', pflow=False)
bookLepton(self.tree, 'lep2', pflow=False)
bookLepton(self.tree, 'lep3', pflow=False)
bookMet(self.tree, 'met')
def process(self, event):
self.tree.reset()
zprimes_ele = getattr(event, self.cfg_ana.zprime_ele)
zprimes_muon = getattr(event, self.cfg_ana.zprime_muon)
if len(zprimes_ele)+len(zprimes_muon)==0: return
jets = getattr(event, self.cfg_ana.jets)
for ijet, jet in enumerate(jets):
if ijet==3:
break
fillParticle(self.tree, 'jet{ijet}'.format(ijet=ijet+1), jet)
self.tree.fill('weight' , sign(event.weight) )
met = getattr(event, self.cfg_ana.met)
fillMet(self.tree, 'met', met)
zprimes_ele.sort(key=lambda x: x.m(), reverse=True)
zprimes_muon.sort(key=lambda x: x.m(), reverse=True)
if len(zprimes_ele)>0 and len(zprimes_muon)==0:
fillParticle(self.tree, 'zprime_ele', zprimes_ele[0])
fillLepton(self.tree, 'lep1', zprimes_ele[0].legs[0])
fillLepton(self.tree, 'lep2', zprimes_ele[0].legs[1])
elif len(zprimes_muon)>0 and len(zprimes_ele)==0 :
fillParticle(self.tree, 'zprime_muon', zprimes_muon[0])
fillLepton(self.tree, 'lep1', zprimes_muon[0].legs[0])
fillLepton(self.tree, 'lep2', zprimes_muon[0].legs[1])
else:
if zprimes_ele[0].m()>zprimes_muon[0].m():
fillParticle(self.tree, 'zprime_ele', zprimes_ele[0])
fillLepton(self.tree, 'lep1', zprimes_ele[0].legs[0])
fillLepton(self.tree, 'lep2', zprimes_ele[0].legs[1])
else:
fillParticle(self.tree, 'zprime_muon', zprimes_muon[0])
fillLepton(self.tree, 'lep1', zprimes_muon[0].legs[0])
fillLepton(self.tree, 'lep2', zprimes_muon[0].legs[1])
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName,
'tree.root']),
'recreate')
self.tree = Tree( 'events', '')
self.tree.var('weight', float)
self.tree.var('weight_1tagex', float)
self.tree.var('weight_2tagex', float)
self.tree.var('weight_1tagin', float)
self.tree.var('missingET', float)
self.tree.var('numberOfElectrons', int)
self.tree.var('numberOfMuons', int)
#trk02 no SD
self.tree.var('Jet1_trk02_tau1', float)
self.tree.var('Jet1_trk02_tau2', float)
self.tree.var('Jet1_trk02_tau3', float)
self.tree.var('Jet2_trk02_tau1', float)
self.tree.var('Jet2_trk02_tau2', float)
self.tree.var('Jet2_trk02_tau3', float)
self.tree.var('Jet1_trk02_tau32', float)
self.tree.var('Jet1_trk02_tau31', float)
self.tree.var('Jet1_trk02_tau21', float)
self.tree.var('Jet2_trk02_tau32', float)
self.tree.var('Jet2_trk02_tau31', float)
self.tree.var('Jet2_trk02_tau21', float)
#bookParticle(self.tree, 'Jet1_trk02_Corr')
#bookParticle(self.tree, 'Jet2_trk02_Corr')
#bookParticle(self.tree, 'Jet1_trk02_MetCorr')
#bookParticle(self.tree, 'Jet2_trk02_MetCorr')
bookParticle(self.tree, 'Jet1_trk02_Corr_MetCorr')
bookParticle(self.tree, 'Jet2_trk02_Corr_MetCorr')
self.tree.var('rapiditySeparation_trk02', float)
self.tree.var('transverseMomentumAsymmetry_trk02', float)
self.tree.var('topJetMassDifference', float)
#trk02 SD
#bookParticle(self.tree, 'Jet1_trk02_SD')
#bookParticle(self.tree, 'Jet2_trk02_SD')
bookParticle(self.tree, 'Jet1_trk02_SD_Corr')
bookParticle(self.tree, 'Jet2_trk02_SD_Corr')
bookParticle(self.tree, 'Jet1_trk02_SD_MetCorr')
bookParticle(self.tree, 'Jet2_trk02_SD_MetCorr')
bookParticle(self.tree, 'Jet1_trk02_SD_Corr_MetCorr')
bookParticle(self.tree, 'Jet2_trk02_SD_Corr_MetCorr')
self.tree.var('Jet1_trk04_SD_Corr_m', float)
self.tree.var('Jet2_trk04_SD_Corr_m', float)
self.tree.var('Jet1_trk08_SD_Corr_m', float)
self.tree.var('Jet2_trk08_SD_Corr_m', float)
bookParticle(self.tree, 'Electron1')
bookParticle(self.tree, 'Electron2')
bookParticle(self.tree, 'Muon1')
bookParticle(self.tree, 'Muon2')
#self.tree.var('BDTvariable_qcd', float)
self.tree.var('Mj1j2_trk02', float)
self.tree.var('Mj1j2_trk02_Corr', float)
self.tree.var('Mj1j2_trk02_MetCorr', float)
self.tree.var('Mj1j2_trk02_Corr_MetCorr', float)
self.tree.var('Mj1j2_pf02', float)
self.tree.var('Mj1j2_pf02_MetCorr', float)
self.tree.var('Mj1j2_pf04', float)
self.tree.var('Mj1j2_pf04_MetCorr', float)
self.tree.var('Mj1j2_pf08', float)
self.tree.var('Mj1j2_pf08_MetCorr', float)
self.tree.var('Jet1_trk02_dR_lep', float)
self.tree.var('Jet2_trk02_dR_lep', float)
# for MVA
self.reader = ROOT.TMVA.Reader()
self.bdt_Jet_trk02_tau1 = array.array('f',[0])
self.bdt_Jet_trk02_tau2 = array.array('f',[0])
self.bdt_Jet_trk02_tau3 = array.array('f',[0])
self.bdt_Jet_trk02_tau21 = array.array('f',[0])
self.bdt_Jet_trk02_tau31 = array.array('f',[0])
self.bdt_Jet_trk02_tau32 = array.array('f',[0])
self.bdt_Jet_trk02_SD_Corr_m = array.array('f',[0])
self.bdt_Jet_trk04_SD_Corr_m = array.array('f',[0])
self.bdt_Jet_trk08_SD_Corr_m = array.array('f',[0])
self.reader.AddVariable("Jet_trk02_tau1", self.bdt_Jet_trk02_tau1 )
self.reader.AddVariable("Jet_trk02_tau2", self.bdt_Jet_trk02_tau2 )
self.reader.AddVariable("Jet_trk02_tau3", self.bdt_Jet_trk02_tau3 )
self.reader.AddVariable("Jet_trk02_tau21", self.bdt_Jet_trk02_tau21 )
self.reader.AddVariable("Jet_trk02_tau31", self.bdt_Jet_trk02_tau31 )
self.reader.AddVariable("Jet_trk02_tau32", self.bdt_Jet_trk02_tau32 )
self.reader.AddVariable("Jet_trk02_SD_Corr_m", self.bdt_Jet_trk02_SD_Corr_m)
self.reader.AddVariable("Jet_trk04_SD_Corr_m", self.bdt_Jet_trk04_SD_Corr_m)
self.reader.AddVariable("Jet_trk08_SD_Corr_m", self.bdt_Jet_trk08_SD_Corr_m)
path = "/eos/experiment/fcc/hh/analyses/W_top_vs_QCD_tagger/heppy_outputs/fcc_v02/TMVA_trainings/"
#path = "/afs/cern.ch/user/d/djamin/fcc_work/BDT_trains/20180223_tagger/"
self.reader.BookMVA("BDT",str(path)+"BDT_BDT_thad_vs_QCD.weights.xml")
self.tree.var('Jet1_thad_vs_QCD_tagger', float)
self.tree.var('Jet2_thad_vs_QCD_tagger', float)
#self.tree.var('label', int)
#self.tree2 = Tree( 'all_events', '')
#self.tree2.var('label', int)
def corrMET(self, jet1, pdg1 , jet2, pdg2, met):
dphi1 = abs(jet1.p4().DeltaPhi(met.p4()))
dphi2 = abs(jet2.p4().DeltaPhi(met.p4()))
metp4 = ROOT.TLorentzVector()
px = met.p4().Px()
py = met.p4().Py()
if (dphi1 < dphi2):
pz = jet1.p4().Pz()/2.
e = math.sqrt(px**2 + py**2 + pz**2)
metp4.SetPxPyPzE(px, py, pz, e)
jetcorr1 = Particle(pdg1, 0, jet1.p4() + metp4, 1)
jetcorr2 = Particle(pdg2, 0, jet2.p4(), 1)
else:
pz = jet2.p4().Pz()/2.
e = math.sqrt(px**2 + py**2 + pz**2)
metp4.SetPxPyPzE(px, py, pz, e)
jetcorr1 = Particle(pdg1, 0, jet1.p4(), 1)
jetcorr2 = Particle(pdg2, 0, jet2.p4() + metp4, 1)
return jetcorr1,jetcorr2
def fillMass(self, jet1, jet2):
mj1j2 = ROOT.TLorentzVector()
j1 = ROOT.TLorentzVector(); j2 = ROOT.TLorentzVector()
j1.SetPtEtaPhiE(jet1.pt(), jet1.eta(), jet1.phi(), jet1.e())
j2.SetPtEtaPhiE(jet2.pt(), jet2.eta(), jet2.phi(), jet2.e())
mj1j2 = j1+j2
return mj1j2.M()
def process(self, event):
self.tree.reset()
jets_trk02 = getattr(event, self.cfg_ana.jets_trk02_1000)
jets_pf02 = getattr(event, self.cfg_ana.jets_pf02_1500)
jets_pf04 = getattr(event, self.cfg_ana.jets_pf04_1000)
jets_pf04_pdg = event.jets_pf04_1000_pdg
jets_pf08 = getattr(event, self.cfg_ana.jets_pf08_1500)
#gen_particles = event.all_particles
jets_pf04_1500 = getattr(event, self.cfg_ana.jets_pf04_1500)
jets_trk04 = getattr(event, self.cfg_ana.jets_trk04_1000)
jets_trk08 = getattr(event, self.cfg_ana.jets_trk08_1000)
electrons = getattr(event, self.cfg_ana.electrons)
muons = getattr(event, self.cfg_ana.muons)
#self.tree2.reset()
##
#label = -1
#part1 = -10000
#part2 = -10000
#index = 0
#part_index = -1
#count = 0
#for j in gen_particles :
# # 1st part
# if (j.status()==22 or j.status()==23) and count==0:
# part1 = j.pdgid()
# count += 1
# part_index = index
# # 2nd part
# if (j.status()==22 or j.status()==23) and count==1 and j.q()+gen_particles[part_index].q()==0:
# part2 = j.pdgid()
# count += 1
# index += 1
#if abs(part1)==6 and abs(part2)==6 : label = 6
#if abs(part1)==5 and abs(part2)==5 : label = 5
#if abs(part1)==4 and abs(part2)==4 : label = 4
#if abs(part1)==3 and abs(part2)==3 : label = 0
#if abs(part1)==2 and abs(part2)==2 : label = 0
#if abs(part1)==1 and abs(part2)==1 : label = 0
## missed cases
#if label == -1 :
# count = 0
# for j in gen_particles :
# if count<10 and abs(j.pdgid())==6 :
# label = 6
# count += 1
#if label==-1 : print "issue label==-1"
##
#self.tree2.fill('label' , label )
#self.tree2.tree.Fill()
Jet1_trk02_dR_lep = 999
Jet2_trk02_dR_lep = 999
if ( len(jets_trk02)>=2 and len(jets_pf02)>=2):
#self.tree.fill('label' , label )
j1 = ROOT.TLorentzVector(); j2 = ROOT.TLorentzVector()
j1.SetPtEtaPhiE(jets_trk02[0].pt(), jets_trk02[0].eta(), jets_trk02[0].phi(), jets_trk02[0].e())
j2.SetPtEtaPhiE(jets_trk02[1].pt(), jets_trk02[1].eta(), jets_trk02[1].phi(), jets_trk02[1].e())
if ( len(electrons)!=0 and len(muons)==0 ):
e = ROOT.TLorentzVector()
e.SetPtEtaPhiE(electrons[0].pt(), electrons[0].eta(), electrons[0].phi(), electrons[0].e())
Jet1_dR = j1.DeltaR(e)
Jet2_dR = j2.DeltaR(e)
if ( len(electrons)==0 and len(muons)!=0 ):
m = ROOT.TLorentzVector()
m.SetPtEtaPhiE(muons[0].pt(), muons[0].eta(), muons[0].phi(), muons[0].e())
Jet1_dR = j1.DeltaR(m)
Jet2_dR = j2.DeltaR(m)
if ( len(electrons)!=0 and len(muons)!=0 ):
isElectron = False; isMuon = False
if ( electrons[0].pt() > muons[0].pt() ): isElectron = True
else: isMuon = True
l = ROOT.TLorentzVector()
if isElectron: l.SetPtEtaPhiE(electrons[0].pt(), electrons[0].eta(), electrons[0].phi(), electrons[0].e())
if isMuon: l.SetPtEtaPhiE(muons[0].pt(), muons[0].eta(), muons[0].phi(), muons[0].e())
Jet1_trk02_dR_lep = j1.DeltaR(l)
Jet2_trk02_dR_lep = j2.DeltaR(l)
self.tree.fill('Jet1_trk02_dR_lep' , Jet1_trk02_dR_lep )
self.tree.fill('Jet2_trk02_dR_lep' , Jet2_trk02_dR_lep )
#had_hadsemilep_lep_decays
self.tree.fill('weight' , event.weight )
self.tree.fill('missingET', event.met.pt())
self.tree.fill('numberOfElectrons', len(electrons))
self.tree.fill('numberOfMuons', len(muons))
self.tree.fill('rapiditySeparation_trk02', abs(jets_trk02[0].eta() - jets_trk02[1].eta()))
self.tree.fill('transverseMomentumAsymmetry_trk02', (jets_trk02[0].pt() - jets_trk02[1].pt())/(jets_trk02[0].pt() + jets_trk02[1].pt()))
self.tree.fill('Jet1_trk02_tau1' , jets_trk02[0].tau1 )
self.tree.fill('Jet1_trk02_tau2' , jets_trk02[0].tau2 )
self.tree.fill('Jet1_trk02_tau3' , jets_trk02[0].tau3 )
self.tree.fill('Jet2_trk02_tau1' , jets_trk02[1].tau1 )
self.tree.fill('Jet2_trk02_tau2' , jets_trk02[1].tau2 )
self.tree.fill('Jet2_trk02_tau3' , jets_trk02[1].tau3 )
Jet1_trk02_tau31 = -999.0
Jet1_trk02_tau21 = -999.0
Jet1_trk02_tau32 = -999.0
Jet2_trk02_tau31 = -999.0
Jet2_trk02_tau21 = -999.0
Jet2_trk02_tau32 = -999.0
if (jets_trk02[0].tau1 != 0.0):
Jet1_trk02_tau31 = jets_trk02[0].tau3/jets_trk02[0].tau1
Jet1_trk02_tau21 = jets_trk02[0].tau2/jets_trk02[0].tau1
if (jets_trk02[0].tau2 != 0.0):
Jet1_trk02_tau32 = jets_trk02[0].tau3/jets_trk02[0].tau2
if (jets_trk02[1].tau1 != 0.0):
Jet2_trk02_tau31 = jets_trk02[1].tau3/jets_trk02[1].tau1
Jet2_trk02_tau21 = jets_trk02[1].tau2/jets_trk02[1].tau1
if (jets_trk02[1].tau2 != 0.0):
Jet2_trk02_tau32 = jets_trk02[1].tau3/jets_trk02[1].tau2
self.tree.fill('Jet1_trk02_tau31', Jet1_trk02_tau31)
self.tree.fill('Jet1_trk02_tau21', Jet1_trk02_tau21)
self.tree.fill('Jet1_trk02_tau32', Jet1_trk02_tau32)
self.tree.fill('Jet2_trk02_tau31', Jet2_trk02_tau31)
self.tree.fill('Jet2_trk02_tau21', Jet2_trk02_tau21)
self.tree.fill('Jet2_trk02_tau32', Jet2_trk02_tau32)
# here is btag, need matching in DR
Jet1_trk02_dR_pf04 = 999
Jet2_trk02_dR_pf04 = 999
for j in jets_pf04:
pf04= ROOT.TLorentzVector()
pf04.SetPtEtaPhiE(j.pt(), j.eta(), j.phi(), j.e())
if j.tags['bf'] > 0:
if pf04.DeltaR(j1)<Jet1_trk02_dR_pf04:
Jet1_trk02_dR_pf04=pf04.DeltaR(j1)
if pf04.DeltaR(j2)<Jet2_trk02_dR_pf04:
Jet2_trk02_dR_pf04=pf04.DeltaR(j2)
#print 'dr j1 ',Jet1_trk02_dR_pf04
#print 'dr j2 ',Jet2_trk02_dR_pf04
pdg1 = 0
pdg2 = 0
if Jet1_trk02_dR_pf04 < 0.3:
pdg1 = 5
if Jet2_trk02_dR_pf04 < 0.3:
pdg2 = 5
# TRF / truth b-tagging -> need at least 2 jets_pf04
use_DELPHES=False
weight_1tagex=0.
weight_2tagex=0.
jet=[]
ipdg=0
for i in range(len(jets_pf04)):
if use_DELPHES==True:
ipdg = jets_pf04[i].tags['flav']
if ipdg!=4 and ipdg!=5 : ipdg=0
else:
ipdg = jets_pf04_pdg[i].flavour
jet.append([jets_pf04[i],ipdg])
if (len(jet)>0): weight_1tagex=getNbTagEx(1,jet,2)
if (len(jet)>1): weight_2tagex=getNbTagEx(2,jet,2)
weight_1tagin=weight_1tagex+weight_2tagex
self.tree.fill('weight_1tagex', weight_1tagex)
self.tree.fill('weight_2tagex', weight_2tagex)
self.tree.fill('weight_1tagin', weight_1tagin)
#MATCHING PF02 and trk02 for CORRECTION
Jet1_trk02_dR_pf02 = 999
Jet2_trk02_dR_pf02 = 999
Jet1_pf02 = None
Jet2_pf02 = None
for j in jets_pf02:
pf02= ROOT.TLorentzVector()
pf02.SetPtEtaPhiE(j.pt(), j.eta(), j.phi(), j.e())
if pf02.DeltaR(j1)<Jet1_trk02_dR_pf02:
Jet1_trk02_dR_pf02=pf02.DeltaR(j1)
Jet1_pf02=j
if pf02.DeltaR(j2)<Jet2_trk02_dR_pf02:
Jet2_trk02_dR_pf02=pf02.DeltaR(j2)
Jet2_pf02=j
#print 'jet1 dr ',Jet1_trk02_dR_pf02,' pf02 ',Jet1_pf02,' trk02 ',jets_trk02[0]
#print 'jet2 dr ',Jet2_trk02_dR_pf02,' pf02 ',Jet2_pf02,' trk02 ',jets_trk02[1]
corr1 = Jet1_pf02.p4().Pt()/j1.Pt()
corr2 = Jet2_pf02.p4().Pt()/j2.Pt()
#print 'corr 1 ',corr1,' corr2 ',corr2
#NORMAL TRK02 SD corrected jet
p4sd1 = ROOT.TLorentzVector(); p4sd2 = ROOT.TLorentzVector()
p4sd1.SetPtEtaPhiM(jets_trk02[0].subjetsSoftDrop[0].p4().Pt()*corr1,
jets_trk02[0].eta(),
jets_trk02[0].phi(),
jets_trk02[0].subjetsSoftDrop[0].p4().M()*corr1)
p4sd2.SetPtEtaPhiM(jets_trk02[1].subjetsSoftDrop[0].p4().Pt()*corr2,
jets_trk02[1].eta(),
jets_trk02[1].phi(),
jets_trk02[1].subjetsSoftDrop[0].p4().M()*corr2)
sdjet1_corr = Particle(pdg1, 0, p4sd1, 1)
sdjet2_corr = Particle(pdg2, 0, p4sd2, 1)
fillParticle(self.tree, 'Jet1_trk02_SD_Corr', sdjet1_corr)
fillParticle(self.tree, 'Jet2_trk02_SD_Corr', sdjet2_corr)
#NORMAL TRK02 SD jet
#sdjet1 = Particle(pdg1, 0, jets_trk02[0].subjetsSoftDrop[0].p4(), 1)
#sdjet2 = Particle(pdg2, 0, jets_trk02[1].subjetsSoftDrop[0].p4(), 1)
#fillParticle(self.tree, 'Jet1_trk02_SD', sdjet1)
#fillParticle(self.tree, 'Jet2_trk02_SD', sdjet2)
#CORRECTED TRK02 jet
p4jet1_corr = ROOT.TLorentzVector(); p4jet2_corr = ROOT.TLorentzVector()
p4jet1_corr.SetPtEtaPhiM(jets_trk02[0].pt()*corr1, jets_trk02[0].eta(), jets_trk02[0].phi(), jets_trk02[0].m()*corr1)
p4jet2_corr.SetPtEtaPhiM(jets_trk02[1].pt()*corr2, jets_trk02[1].eta(), jets_trk02[1].phi(), jets_trk02[1].m()*corr2)
jet1_corr = Particle(pdg1, 0, p4jet1_corr, 1)
jet2_corr = Particle(pdg2, 0, p4jet2_corr, 1)
#fillParticle(self.tree, 'Jet1_trk02_Corr', jet1_corr)
#fillParticle(self.tree, 'Jet2_trk02_Corr', jet2_corr)
# associate MET to one jet or another based on softdrop
sdjetmet1, sdjetmet2 = self.corrMET(jets_trk02[0].subjetsSoftDrop[0], pdg1, jets_trk02[1].subjetsSoftDrop[0], pdg2, event.met)
fillParticle(self.tree, 'Jet1_trk02_SD_MetCorr', sdjetmet1)
fillParticle(self.tree, 'Jet2_trk02_SD_MetCorr', sdjetmet2)
sdjetmet1, sdjetmet2 = self.corrMET(sdjet1_corr, pdg1, sdjet2_corr, pdg2, event.met)
fillParticle(self.tree, 'Jet1_trk02_SD_Corr_MetCorr', sdjetmet1)
fillParticle(self.tree, 'Jet2_trk02_SD_Corr_MetCorr', sdjetmet2)
######################
# trkjet04 mass info #
######################
#MATCHING PF04 and trk04 for CORRECTION
Jet1_trk04_dR_pf04 = 999
Jet2_trk04_dR_pf04 = 999
Jet1_pf04 = None
Jet2_pf04 = None
for j in jets_pf04_1500:
pf04= ROOT.TLorentzVector()
pf04.SetPtEtaPhiE(j.pt(), j.eta(), j.phi(), j.e())
if pf04.DeltaR(j1)<Jet1_trk04_dR_pf04:
Jet1_trk04_dR_pf04=pf04.DeltaR(j1)
Jet1_pf04=j
if pf04.DeltaR(j2)<Jet2_trk04_dR_pf04:
Jet2_trk04_dR_pf04=pf04.DeltaR(j2)
Jet2_pf04=j
corr1_04 = Jet1_pf04.p4().Pt()/j1.Pt()
corr2_04 = Jet2_pf04.p4().Pt()/j2.Pt()
#NORMAL TRK04 SD corrected jet
p4sd1_04 = ROOT.TLorentzVector(); p4sd2_04 = ROOT.TLorentzVector()
Jet1_trk04_SD_Corr_m = -1000. ; Jet2_trk04_SD_Corr_m = -1000.
if len(jets_trk04)>=1 :
p4sd1_04.SetPtEtaPhiM(jets_trk04[0].subjetsSoftDrop[0].p4().Pt()*corr1_04,
jets_trk04[0].eta(),
jets_trk04[0].phi(),
jets_trk04[0].subjetsSoftDrop[0].p4().M()*corr1_04)
pdg1 = 0
sdjet1_corr_04 = Particle(pdg1, 0, p4sd1_04, 1)
Jet1_trk04_SD_Corr_m = sdjet1_corr_04.p4().M()
if len(jets_trk04)>=2 :
p4sd2_04.SetPtEtaPhiM(jets_trk04[1].subjetsSoftDrop[0].p4().Pt()*corr2_04,
jets_trk04[1].eta(),
jets_trk04[1].phi(),
jets_trk04[1].subjetsSoftDrop[0].p4().M()*corr2_04)
pdg2 = 0
sdjet2_corr_04 = Particle(pdg2, 0, p4sd2_04, 1)
Jet2_trk04_SD_Corr_m = sdjet2_corr_04.p4().M()
self.tree.fill('Jet1_trk04_SD_Corr_m', Jet1_trk04_SD_Corr_m)
self.tree.fill('Jet2_trk04_SD_Corr_m', Jet2_trk04_SD_Corr_m)
######################
# trkjet08 mass info #
######################
#MATCHING PF08 and trk08 for CORRECTION
Jet1_trk08_dR_pf08 = 999
Jet2_trk08_dR_pf08 = 999
Jet1_pf08 = None
Jet2_pf08 = None
for j in jets_pf08:
pf08= ROOT.TLorentzVector()
pf08.SetPtEtaPhiE(j.pt(), j.eta(), j.phi(), j.e())
if pf08.DeltaR(j1)<Jet1_trk08_dR_pf08:
Jet1_trk08_dR_pf08=pf08.DeltaR(j1)
Jet1_pf08=j
if pf08.DeltaR(j2)<Jet2_trk08_dR_pf08:
Jet2_trk08_dR_pf08=pf08.DeltaR(j2)
Jet2_pf08=j
corr1_08 = Jet1_pf08.p4().Pt()/j1.Pt()
corr2_08 = Jet2_pf08.p4().Pt()/j2.Pt()
#NORMAL TRK08 SD corrected jet
p4sd1_08 = ROOT.TLorentzVector(); p4sd2_08 = ROOT.TLorentzVector()
Jet1_trk08_SD_Corr_m = -1000. ; Jet2_trk08_SD_Corr_m = -1000.
if len(jets_trk08)>=1 :
p4sd1_08.SetPtEtaPhiM(jets_trk08[0].subjetsSoftDrop[0].p4().Pt()*corr1_08,
jets_trk08[0].eta(),
jets_trk08[0].phi(),
jets_trk08[0].subjetsSoftDrop[0].p4().M()*corr1_08)
pdg1 = 0
sdjet1_corr_08 = Particle(pdg1, 0, p4sd1_08, 1)
Jet1_trk08_SD_Corr_m = sdjet1_corr_08.p4().M()
if len(jets_trk08)>=2 :
p4sd2_08.SetPtEtaPhiM(jets_trk08[1].subjetsSoftDrop[0].p4().Pt()*corr2_08,
jets_trk08[1].eta(),
jets_trk08[1].phi(),
jets_trk08[1].subjetsSoftDrop[0].p4().M()*corr2_08)
pdg2 = 0
sdjet2_corr_08 = Particle(pdg2, 0, p4sd2_08, 1)
Jet2_trk08_SD_Corr_m = sdjet2_corr_08.p4().M()
self.tree.fill('Jet1_trk08_SD_Corr_m', Jet1_trk08_SD_Corr_m)
self.tree.fill('Jet2_trk08_SD_Corr_m', Jet2_trk08_SD_Corr_m)
if (len(jets_trk02)>1):
self.tree.fill( 'Mj1j2_trk02',self.fillMass(jets_trk02[0],jets_trk02[1]))
self.tree.fill( 'Mj1j2_trk02_Corr',self.fillMass(jet1_corr,jet2_corr))
jetmet1, jetmet2 = self.corrMET(jets_trk02[0], pdg1, jets_trk02[1], pdg2, event.met)
self.tree.fill( 'Mj1j2_trk02_MetCorr',self.fillMass(jetmet1,jetmet2))
#fillParticle(self.tree, 'Jet1_trk02_MetCorr', jetmet1)
#fillParticle(self.tree, 'Jet2_trk02_MetCorr', jetmet2)
jetmet1, jetmet2 = self.corrMET(jet1_corr, pdg1, jet2_corr, pdg2, event.met)
self.tree.fill( 'Mj1j2_trk02_Corr_MetCorr',self.fillMass(jetmet1,jetmet2))
fillParticle(self.tree, 'Jet1_trk02_Corr_MetCorr', jetmet1)
fillParticle(self.tree, 'Jet2_trk02_Corr_MetCorr', jetmet2)
if (len(jets_pf02)>1):
self.tree.fill( 'Mj1j2_pf02', self.fillMass(jets_pf02[0],jets_pf02[1]))
jetmet1, jetmet2 = self.corrMET(jets_pf02[0], pdg1, jets_pf02[1], pdg2, event.met)
self.tree.fill( 'Mj1j2_pf02_MetCorr', self.fillMass(jetmet1,jetmet2))
if (len(jets_pf04)>1):
self.tree.fill( 'Mj1j2_pf04', self.fillMass(jets_pf04[0],jets_pf04[1]))
jetmet1, jetmet2 = self.corrMET(jets_pf04[0], pdg1, jets_pf04[1], pdg2, event.met)
self.tree.fill( 'Mj1j2_pf04_MetCorr', self.fillMass(jetmet1,jetmet2))
if (len(jets_pf08)>1):
self.tree.fill( 'Mj1j2_pf08', self.fillMass(jets_pf08[0],jets_pf08[1]))
jetmet1, jetmet2 = self.corrMET(jets_pf08[0], pdg1, jets_pf08[1], pdg2, event.met)
self.tree.fill( 'Mj1j2_pf08_MetCorr', self.fillMass(jetmet1,jetmet2))
if ( len(electrons) >=1 ): fillParticle(self.tree, 'Electron1', electrons[0])
if ( len(electrons) >=2 ): fillParticle(self.tree, 'Electron2', electrons[1])
if ( len(muons) >=1 ): fillParticle(self.tree, 'Muon1', muons[0])
if ( len(muons) >=2 ): fillParticle(self.tree, 'Muon2', muons[1])
###################################
#TMVA Stuff Starts!
###################################
self.bdt_Jet_trk02_tau1[0] = jets_trk02[0].tau1
self.bdt_Jet_trk02_tau2[0] = jets_trk02[0].tau2
self.bdt_Jet_trk02_tau3[0] = jets_trk02[0].tau3
self.bdt_Jet_trk02_tau21[0] = Jet1_trk02_tau21
self.bdt_Jet_trk02_tau31[0] = Jet1_trk02_tau31
self.bdt_Jet_trk02_tau32[0] = Jet1_trk02_tau32
self.bdt_Jet_trk02_SD_Corr_m[0] = sdjet1_corr.p4().M()
if len(jets_trk04)>=1 : self.bdt_Jet_trk04_SD_Corr_m[0] = sdjet1_corr_04.p4().M()
else : self.bdt_Jet_trk04_SD_Corr_m[0] = -1000.
if len(jets_trk08)>=1 : self.bdt_Jet_trk08_SD_Corr_m[0] = sdjet1_corr_08.p4().M()
else : self.bdt_Jet_trk08_SD_Corr_m[0] = -1000.
mva_value = self.reader.EvaluateMVA("BDT")
self.tree.fill( 'Jet1_thad_vs_QCD_tagger', mva_value)
#
self.bdt_Jet_trk02_tau1[0] = jets_trk02[1].tau1
self.bdt_Jet_trk02_tau2[0] = jets_trk02[1].tau2
self.bdt_Jet_trk02_tau3[0] = jets_trk02[1].tau3
self.bdt_Jet_trk02_tau21[0] = Jet2_trk02_tau21
self.bdt_Jet_trk02_tau31[0] = Jet2_trk02_tau31
self.bdt_Jet_trk02_tau32[0] = Jet2_trk02_tau32
self.bdt_Jet_trk02_SD_Corr_m[0] = sdjet2_corr.p4().M()
if len(jets_trk04)>=2 : self.bdt_Jet_trk04_SD_Corr_m[0] = sdjet2_corr_04.p4().M()
else : self.bdt_Jet_trk04_SD_Corr_m[0] = -1000.
if len(jets_trk08)>=2 : self.bdt_Jet_trk08_SD_Corr_m[0] = sdjet2_corr_08.p4().M()
else : self.bdt_Jet_trk08_SD_Corr_m[0] = -1000.
mva_value = self.reader.EvaluateMVA("BDT")
self.tree.fill( 'Jet2_thad_vs_QCD_tagger', mva_value)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('njets', float)
self.tree.var('nleptons', float)
bookParticle(self.tree, 'l1')
bookParticle(self.tree, 'l2')
bookParticle(self.tree, 'l3')
bookParticle(self.tree, 'l4')
bookParticle(self.tree, 'j1')
bookParticle(self.tree, 'j2')
bookParticle(self.tree, 'j3')
bookParticle(self.tree, 'j4')
bookParticle(self.tree, 'gj1')
bookParticle(self.tree, 'gj2')
bookParticle(self.tree, 'gl1')
bookParticle(self.tree, 'gl2')
bookParticle(self.tree, 'gv1')
bookParticle(self.tree, 'gv2')
bookMet(self.tree, 'met')
'''
def filterHard(self, event):
genparts = event.gen_particles
print '--------------------------------------'
for gen in genparts:
if gen.status > 20 and gen.status < 30:
print gen'''
def process(self, event):
self.tree.reset()
genparts = event.gen_particles
#print '--------------------------------------'
genjets = []
genneus = []
genleps = []
genws = []
for gen in genparts:
if gen.status() > 20 and gen.status() < 30:
if abs(gen.pdgid()) < 5 and gen.pt() > 0.:
genjets.append(gen)
if abs(gen.pdgid()) == 11 or abs(gen.pdgid()) == 13 or abs(
gen.pdgid()) == 15:
genleps.append(gen)
if abs(gen.pdgid()) == 12 or abs(gen.pdgid()) == 14 or abs(
gen.pdgid()) == 16:
genneus.append(gen)
if abs(gen.pdgid()) == 24:
genws.append(gen)
if len(genleps) < 2:
genleps = []
for gen in genparts:
if gen.status() == 1 and gen.pt() > 5.:
if abs(gen.pdgid()) == 11 or abs(gen.pdgid()) == 13 or abs(
gen.pdgid()) == 15:
genleps.append(gen)
if len(genneus) < 2:
genneus = []
for gen in genparts:
if gen.status() == 1 and gen.pt() > 5:
if abs(gen.pdgid()) == 12 or abs(gen.pdgid()) == 14 or abs(
gen.pdgid()) == 16:
genneus.append(gen)
'''if len(genleps) < 2:
for gen in genparts:
if gen.status() > 20 and gen.status() < 30 :
print gen'''
genjets.sort(key=lambda x: x.pt(), reverse=True)
genneus.sort(key=lambda x: x.pt(), reverse=True)
genleps.sort(key=lambda x: x.pt(), reverse=True)
if len(genjets) > 0:
fillParticle(self.tree, 'gj1', genjets[0])
if len(genjets) > 1:
fillParticle(self.tree, 'gj2', genjets[1])
if len(genneus) > 0:
fillParticle(self.tree, 'gv1', genneus[0])
if len(genneus) > 1:
fillParticle(self.tree, 'gv2', genneus[1])
if len(genleps) > 0:
fillParticle(self.tree, 'gl1', genleps[0])
if len(genleps) > 1:
fillParticle(self.tree, 'gl2', genleps[1])
'''for gen in genparts:
if gen.status() == 1 and (abs(gen.pdgid()) == 11 or abs(gen.pdgid()) == 13 or abs(gen.pdgid()) == 15 or abs(gen.pdgid()) == 12 or abs(gen.pdgid()) == 14 or abs(gen.pdgid()) == 16):
print gen
print len(genjets), len(genneus), len(genleps)'''
'''print ''
for gen in genparts:
if gen.status() == 1 and (abs(gen.pdgid()) == 11 or abs(gen.pdgid()) == 13 or abs(gen.pdgid()) == 15 or abs(gen.pdgid()) == 12 or abs(gen.pdgid()) == 14 or abs(gen.pdgid()) == 16):
print gen
print len(genjets), len(genneus), len(genleps)
print ''
for gen in genparts:
print gen
'''
leptons = event.selected_leptons
leptons.sort(key=lambda x: x.pt(), reverse=True)
jets = event.jets_nolepton
jets.sort(key=lambda x: x.pt(), reverse=True)
met = event.met
self.tree.fill('weight', event.weight)
self.tree.fill('njets', len(jets))
self.tree.fill('nleptons', len(leptons))
fillMet(self.tree, 'met', met)
if len(leptons) > 0:
fillParticle(self.tree, 'l1', leptons[0])
if len(leptons) > 1:
fillParticle(self.tree, 'l2', leptons[1])
if len(leptons) > 2:
fillParticle(self.tree, 'l3', leptons[2])
if len(leptons) > 3:
fillParticle(self.tree, 'l4', leptons[3])
if len(jets) > 0:
fillParticle(self.tree, 'j1', jets[0])
if len(jets) > 1:
fillParticle(self.tree, 'j2', jets[1])
if len(jets) > 2:
fillParticle(self.tree, 'j3', jets[2])
if len(jets) > 3:
fillParticle(self.tree, 'j4', jets[3])
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducerBDT(Analyzer):
def beginLoop(self, setup):
super(TreeProducerBDT, self).beginLoop(setup)
self.rootfileS = TFile('/'.join([self.dirName,
'treeS.root']),
'recreate')
self.treeS = Tree( 'events', '')
self.treeS.var('weight', float)
bookParticle(self.treeS, 'jet')
bookParticle(self.treeS, 'softDropped_jet')
self.treeS.var('jet_tau1', float)
self.treeS.var('jet_tau2', float)
self.treeS.var('jet_tau3', float)
self.treeS.var('jet_tau32', float)
self.treeS.var('jet_tau31', float)
self.treeS.var('jet_tau21', float)
self.treeS.var('jet_flow15', float)
self.treeS.var('jet_flow25', float)
self.treeS.var('jet_flow35', float)
self.treeS.var('jet_flow45', float)
self.treeS.var('jet_flow55', float)
self.treeS.var('jet_nbs', float)
self.rootfileB = TFile('/'.join([self.dirName,
'treeB.root']),
'recreate')
self.treeB = Tree( 'events', '')
bookParticle(self.treeB, 'jet')
bookParticle(self.treeB, 'softDropped_jet')
self.treeB.var('jet_tau1', float)
self.treeB.var('jet_tau2', float)
self.treeB.var('jet_tau3', float)
self.treeB.var('jet_tau32', float)
self.treeB.var('jet_tau31', float)
self.treeB.var('jet_tau21', float)
self.treeB.var('jet_flow15', float)
self.treeB.var('jet_flow25', float)
self.treeB.var('jet_flow35', float)
self.treeB.var('jet_flow45', float)
self.treeB.var('jet_flow55', float)
self.treeB.var('jet_nbs', float)
def process(self, event):
self.treeS.reset()
self.treeB.reset()
gen_bs = getattr(event, self.cfg_ana.gen_bs)
gen_higgses = getattr(event, self.cfg_ana.gen_higgses)
gen_higgses.sort(key=lambda x: x.pt(), reverse = True)
gen_tops = getattr(event, self.cfg_ana.gen_tops)
gen_tops.sort(key=lambda x: x.pt(), reverse = True)
jets = getattr(event, self.cfg_ana.fatjets)
leptons = getattr(event, self.cfg_ana.selected_leptons)
bjets = event.selected_bs
if len(gen_higgses) > 1:
hh_gen = Resonance(gen_higgses[0], gen_higgses[1], 25)
ljets = []
#_________________________________________________________________
# count number of bjets inside jet
for jet in jets:
is_light = True
setattr(jet, 'nbs', 0)
for b in bjets:
drjb = deltaR(b, jet)
if drjb < 1.5:
jet.nbs += 1
#_________________________________________________________________
# compute eflow variables
R = 1.5
for jet in jets:
setattr(jet, 'flow', [0]*5)
constituent_vector = TLorentzVector()
#print jet.pt, jet.flow
for n in range(1,5+1):
#print n
for constituent in jet.jetConstituents[1:]:
#print constituent.pt()
dR = jet.p4().DeltaR(constituent.p4())
if ((dR >= (n-1)/5.*R) and (dR < n/5.*R)):
#print 'in ring', dR
jet.flow[n-1] += abs(constituent.pt())/abs(jet.pt())
#print '--------------- new event --------------------------------'
if len(leptons) > 0 and len(jets) > 1:
#print len(jets), len(leptons)
#print deltaR(jets[0], leptons[0]), deltaR(jets[1], leptons[0])
selected_higgs_jets = []
selected_top_jets = []
# to decide wheather top or higgs jet will be done with MVA
# for now just cheat by checking MC truth
for jet in jets:
drmin_h = 999.
drmin_t = 999.
for higgs in gen_higgses:
drjh = deltaR(higgs, jet)
if drjh < drmin_h:
drmin_h = drjh
for top in gen_tops:
drjt = deltaR(top, jet)
if drjt < drmin_t:
drmin_t = drjt
if drmin_h < drmin_t and drmin_h < 1.0:
selected_higgs_jets.append(jet)
elif drmin_t < drmin_h and drmin_t < 1.0:
selected_top_jets.append(jet)
if len(selected_higgs_jets) > 0 and len(selected_top_jets) > 0 :
for tree in [self.treeS, self.treeB]:
if tree == self.treeS:
jet = selected_higgs_jets[0]
else:
jet = selected_top_jets[0]
fillParticle(tree, 'jet', jet)
fillParticle(tree, 'softDropped_jet', jet.subjetsSoftDrop[0])
tree.fill('jet_tau1' , jet.tau1 )
tree.fill('jet_tau2' , jet.tau2 )
tree.fill('jet_tau3' , jet.tau3 )
jet_tau31 = -9.0
jet_tau21 = -9.0
jet_tau32 = -9.0
if (jet.tau1 != 0.0):
jet_tau31 = jet.tau3/jet.tau1
jet_tau21 = jet.tau2/jet.tau1
if (jet.tau2 != 0.0):
jet_tau32 = jet.tau3/jet.tau2
tree.fill('jet_tau31' , jet_tau31 )
tree.fill('jet_tau32' , jet_tau32 )
tree.fill('jet_tau21' , jet_tau21 )
#print 'filling: ',jet.flow[0], jet.flow[1], jet.flow[2], jet.flow[3], jet.flow[4]
tree.fill('jet_flow15', jet.flow[0])
tree.fill('jet_flow25', jet.flow[1])
tree.fill('jet_flow35', jet.flow[2])
tree.fill('jet_flow45', jet.flow[3])
tree.fill('jet_flow55', jet.flow[4])
tree.fill('jet_nbs', jet.nbs)
tree.tree.Fill()
def write(self, setup):
self.rootfileS.Write()
self.rootfileS.Close()
self.rootfileB.Write()
self.rootfileB.Close()
infname = sys.argv[1]
sh = shelve.open(infname)
outevents = list()
events = dict()
outfname = infname.replace(".shv", ".root")
print "input:", infname
print "output", outfname
f = TFile(outfname, "RECREATE")
tree = Tree("events", "tree for gael")
tree.var("rec1_e")
tree.var("rec1_gen_e")
tree.var("rec1_dr")
tree.var("rec2_e")
tree.var("rec2_gen_e")
tree.var("rec2_dr")
tree.var("ak1_e")
tree.var("ak1_gen_e")
tree.var("ak1_dr")
tree.var("ak2_e")
tree.var("ak2_gen_e")
tree.var("ak2_dr")
tree.var("drgen")
def process_event(ievent):
from ROOT import TFile
from heppy.statistics.tree import Tree
outfile = TFile('test_tree.root', 'recreate')
tree = Tree('test_tree', 'A test tree')
tree.var('var1')
for i in range(100):
tree.fill('var1', i)
tree.tree.Fill()
print 'creating a tree', tree.tree.GetName(),\
tree.tree.GetEntries(), 'entries in',\
outfile.GetName()
outfile.Write()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('weight_1tagex', float)
self.tree.var('weight_2tagex', float)
self.tree.var('weight_1tagin', float)
bookParticle(self.tree, 'Jet1_pf04')
bookParticle(self.tree, 'Jet2_pf04')
self.tree.var('Mj1j2_pf04', float)
self.tree.var('Mj1j2_pf04_MetCorr', float)
self.tree.var('Mj1j2_pf04_MetCorr2', float)
self.tree.var('mt', float)
self.tree.var('mr', float)
self.tree.var('mr2', float)
self.tree.var('mr3', float)
self.tree.var('dr', float)
self.tree.var('dphi', float)
self.tree.var('dphi_met', float)
self.tree.var('ntau', int)
bookMet(self.tree, 'met')
def corrMET(self, jet1, jet2, met):
dphi1 = abs(jet1.p4().DeltaPhi(met.p4()))
dphi2 = abs(jet2.p4().DeltaPhi(met.p4()))
metp4 = ROOT.TLorentzVector()
px = met.p4().Px()
py = met.p4().Py()
if (dphi1 < dphi2):
pz = jet1.p4().Pz() / 2.
e = math.sqrt(px**2 + py**2 + pz**2)
metp4.SetPxPyPzE(px, py, pz, e)
jetcorr1 = Particle(15, 0, jet1.p4() + metp4, 1)
jetcorr2 = Particle(15, 0, jet2.p4(), 1)
else:
pz = jet2.p4().Pz() / 2.
e = math.sqrt(px**2 + py**2 + pz**2)
metp4.SetPxPyPzE(px, py, pz, e)
jetcorr1 = Particle(15, 0, jet1.p4(), 1)
jetcorr2 = Particle(15, 0, jet2.p4() + metp4, 1)
return jetcorr1, jetcorr2
def corrMET2(self, jet1, jet2, met):
metp4 = ROOT.TLorentzVector()
px = met.p4().Px()
py = met.p4().Py()
if (jet1.p4().Pt() < jet2.p4().Pt()):
pz = jet1.p4().Pz() / 2.
e = math.sqrt(px**2 + py**2 + pz**2)
metp4.SetPxPyPzE(px, py, pz, e)
jetcorr1 = Particle(15, 0, jet1.p4() + metp4, 1)
jetcorr2 = Particle(15, 0, jet2.p4(), 1)
else:
pz = jet2.p4().Pz() / 2.
e = math.sqrt(px**2 + py**2 + pz**2)
metp4.SetPxPyPzE(px, py, pz, e)
jetcorr1 = Particle(15, 0, jet1.p4(), 1)
jetcorr2 = Particle(15, 0, jet2.p4() + metp4, 1)
return jetcorr1, jetcorr2
def fillMass(self, jet1, jet2):
mj1j2 = ROOT.TLorentzVector()
j1 = ROOT.TLorentzVector()
j2 = ROOT.TLorentzVector()
j1.SetPtEtaPhiE(jet1.pt(), jet1.eta(), jet1.phi(), jet1.e())
j2.SetPtEtaPhiE(jet2.pt(), jet2.eta(), jet2.phi(), jet2.e())
mj1j2 = j1 + j2
return mj1j2.M()
def process(self, event):
self.tree.reset()
jets_pf04 = getattr(event, self.cfg_ana.jets_pf04_trf)
ntau = 0
for j in jets_pf04:
if j.tags['tauf'] > 0: ntau += 1
self.tree.fill('ntau', ntau)
if len(jets_pf04) < 2: return
weight_1tagex = getOneTagEx(jets_pf04[0], jets_pf04[1])
weight_2tagex = getTwoTagEx(jets_pf04[0], jets_pf04[1])
weight_1tagin = weight_1tagex + weight_2tagex
self.tree.fill('weight_1tagex', weight_1tagex)
self.tree.fill('weight_2tagex', weight_2tagex)
self.tree.fill('weight_1tagin', weight_1tagin)
#print '1tagex: ',weight_1tagex,' 2tagex: ',weight_2tagex,' 1tagin: ',weight_1tagin
mtautau = self.fillMass(jets_pf04[0], jets_pf04[1])
self.tree.fill('Mj1j2_pf04', mtautau)
jetmet1, jetmet2 = self.corrMET(jets_pf04[0], jets_pf04[1], event.met)
mtautaumet = self.fillMass(jetmet1, jetmet2)
self.tree.fill('Mj1j2_pf04_MetCorr', mtautaumet)
jetmet1, jetmet2 = self.corrMET2(jets_pf04[0], jets_pf04[1], event.met)
mtautaumet = self.fillMass(jetmet1, jetmet2)
self.tree.fill('Mj1j2_pf04_MetCorr2', mtautaumet)
Zprime = ROOT.TLorentzVector()
j1 = ROOT.TLorentzVector()
j2 = ROOT.TLorentzVector()
j1.SetPtEtaPhiE(jets_pf04[0].pt(), jets_pf04[0].eta(),
jets_pf04[0].phi(), jets_pf04[0].e())
j2.SetPtEtaPhiE(jets_pf04[1].pt(), jets_pf04[1].eta(),
jets_pf04[1].phi(), jets_pf04[1].e())
Zprime = j1 + j2
Zppx = Zprime.Pt() * math.cos(Zprime.Phi())
Zppy = Zprime.Pt() * math.sin(Zprime.Phi())
metx = event.met.pt() * math.cos(event.met.phi())
mety = event.met.pt() * math.sin(event.met.phi())
ptZp = math.sqrt((Zppx + metx)**2 + (Zppy + mety)**2)
dphi_ll = TVector2.Phi_mpi_pi(j1.Phi() - j2.Phi())
dphi_llmet = TVector2.Phi_mpi_pi(Zprime.Phi() - event.met.phi())
self.tree.fill('dphi', dphi_ll)
self.tree.fill('dphi_met', dphi_llmet)
mt = math.sqrt(2 * Zprime.Pt() * event.met.pt() *
(1 - math.cos(dphi_llmet)))
mll = Zprime.M()
ptll = Zprime.Pt()
met = event.met.pt()
met_d_ptll = metx * Zppx + mety * Zppy
mr = math.sqrt((mtautau**2 - met_d_ptll + math.sqrt(
(mtautau**2 + ptll**2) * (mll**2 + met**2))))
pl1 = ROOT.TLorentzVector()
pl2 = ROOT.TLorentzVector()
pMet = ROOT.TVector3()
pl1.SetPtEtaPhiM(jets_pf04[0].pt(), jets_pf04[0].eta(),
jets_pf04[0].phi(), jets_pf04[0].m())
pl2.SetPtEtaPhiM(jets_pf04[1].pt(), jets_pf04[1].eta(),
jets_pf04[1].phi(), jets_pf04[1].m())
pMet.SetPtEtaPhi(event.met.pt(), 0.0, event.met.phi())
self.tree.fill('mt', mt)
self.tree.fill('dr', pl1.DeltaR(pl2))
fillParticle(self.tree, 'Jet1_pf04', jets_pf04[0])
fillParticle(self.tree, 'Jet2_pf04', jets_pf04[1])
self.tree.fill('weight', sign(event.weight))
met = getattr(event, self.cfg_ana.met)
fillMet(self.tree, 'met', met)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('nljets', float)
self.tree.var('nbjets', float)
self.tree.var('njets', float)
self.tree.var('nlep', float)
self.tree.var('drbb', float)
self.tree.var('draa', float)
bookParticle(self.tree, 'haa')
bookParticle(self.tree, 'hbb')
bookLepton(self.tree, 'a1')
bookLepton(self.tree, 'a2')
bookLepton(self.tree, 'b1')
bookLepton(self.tree, 'b2')
bookParticle(self.tree, 'hh')
bookMet(self.tree, 'met')
def process(self, event):
self.tree.reset()
haas = getattr(event, self.cfg_ana.haas)
hbbs = getattr(event, self.cfg_ana.hbbs)
haas.sort(key=lambda x: abs(x.m() - 125.))
hbbs.sort(key=lambda x: abs(x.m() - 125.))
if len(haas) > 0 and len(hbbs) > 0:
self.tree.fill('weight', event.weight)
# jet multiplicities
self.tree.fill('nbjets', len(event.selected_bs))
self.tree.fill('nljets', len(event.selected_lights))
self.tree.fill('njets',
len(event.selected_lights) + len(event.selected_bs))
self.tree.fill('nlep', len(event.selected_leptons))
# missing Et
fillMet(self.tree, 'met', event.met)
# Reco higgses
photons = []
photons.append(haas[0].leg1())
photons.append(haas[0].leg2())
photons.sort(key=lambda x: x.pt(), reverse=True)
bs = []
bs.append(hbbs[0].leg1())
bs.append(hbbs[0].leg2())
bs.sort(key=lambda x: x.pt(), reverse=True)
hh = Resonance(haas[0], hbbs[0], 25)
fillParticle(self.tree, 'hh', hh)
fillParticle(self.tree, 'haa', haas[0])
fillParticle(self.tree, 'hbb', hbbs[0])
fillParticle(self.tree, 'a1', photons[0])
fillParticle(self.tree, 'a2', photons[1])
fillParticle(self.tree, 'b1', bs[0])
fillParticle(self.tree, 'b2', bs[1])
drbb = deltaR(bs[0], bs[1])
draa = deltaR(photons[0], photons[1])
self.tree.fill('draa', draa)
self.tree.fill('drbb', drbb)
self.tree.tree.Fill()
'''phos = getattr(event, self.cfg_ana.photons)
bs = getattr(event, self.cfg_ana.bs)
phos.sort(key=lambda x: x.pt(), reverse=True)
bs.sort(key=lambda x: x.pt(), reverse=True)'''
#print len(phos), len(bs)
'''if len(phos) > 1 and len(bs) > 1 :
drbb = deltaR(bs[0], bs[1])
draa = deltaR(phos[0], phos[1])
haa = Resonance( phos[0], phos[1], 25)
hbb = Resonance( bs[0], bs[1], 25)
hh = Resonance( haa, hbb, 25)
if haa.m() > 100 and haa.m() < 150 and hbb.m() > 60 and hbb.m() < 200:
self.tree.fill('weight' , event.weight )
# jet multiplicities
self.tree.fill('nbjets' , len(event.selected_bs) )
self.tree.fill('nljets' , len(event.selected_lights) )
self.tree.fill('njets' , len(event.selected_lights) + len(event.selected_bs))
self.tree.fill('nlep' , len(event.selected_leptons))
self.tree.fill('draa' , draa)
self.tree.fill('drbb' , drbb)
# missing Et
fillMet(self.tree, 'met', event.met)
fillParticle(self.tree, 'hh', hh)
fillParticle(self.tree, 'haa', haa)
fillParticle(self.tree, 'hbb', hbb)
fillParticle(self.tree, 'a1', phos[0])
fillParticle(self.tree, 'a2', phos[1])
fillParticle(self.tree, 'b1', bs[0])
fillParticle(self.tree, 'b2', bs[1])
self.tree.tree.Fill()'''
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('Jet1_tau1', float)
self.tree.var('Jet1_tau2', float)
self.tree.var('Jet1_tau3', float)
self.tree.var('Jet2_tau1', float)
self.tree.var('Jet2_tau2', float)
self.tree.var('Jet2_tau3', float)
self.tree.var('Jet1_tau32', float)
self.tree.var('Jet1_tau31', float)
self.tree.var('Jet1_tau21', float)
self.tree.var('Jet2_tau32', float)
self.tree.var('Jet2_tau31', float)
self.tree.var('Jet2_tau21', float)
bookParticle(self.tree, 'Jet1')
bookParticle(self.tree, 'Jet2')
bookParticle(self.tree, 'softDroppedJet1')
bookParticle(self.tree, 'softDroppedJet2')
bookParticle(self.tree, 'trimmedJet1')
bookParticle(self.tree, 'trimmedJet2')
bookParticle(self.tree, 'prunedJet1')
bookParticle(self.tree, 'prunedJet2')
self.tree.var('RSGravitonReconstructedMass', float)
self.tree.var('RSGravitonReconstructedMass_trimmed', float)
self.tree.var('RSGravitonReconstructedMass_softDropped', float)
self.tree.var('RSGravitonReconstructedMass_pruned', float)
self.tree.var('Jet1_Flow15', float)
self.tree.var('Jet1_Flow25', float)
self.tree.var('Jet1_Flow35', float)
self.tree.var('Jet1_Flow45', float)
self.tree.var('Jet1_Flow55', float)
self.tree.var('Jet2_Flow15', float)
self.tree.var('Jet2_Flow25', float)
self.tree.var('Jet2_Flow35', float)
self.tree.var('Jet2_Flow45', float)
self.tree.var('Jet2_Flow55', float)
self.tree.var('rapiditySeparation', float)
self.tree.var('transverseMomentumAsymmetry', float)
def process(self, event):
self.tree.reset()
jets = getattr(event, self.cfg_ana.fatjets)
if (len(jets) > 1):
self.tree.fill('weight', event.weight)
self.tree.fill('rapiditySeparation',
abs(jets[0].eta() - jets[1].eta()))
self.tree.fill('transverseMomentumAsymmetry',
(jets[0].pt() - jets[1].pt()) /
(jets[0].pt() + jets[1].pt()))
self.tree.fill('Jet1_tau1', jets[0].tau1)
self.tree.fill('Jet1_tau2', jets[0].tau2)
self.tree.fill('Jet1_tau3', jets[0].tau3)
self.tree.fill('Jet2_tau1', jets[1].tau1)
self.tree.fill('Jet2_tau2', jets[1].tau2)
self.tree.fill('Jet2_tau3', jets[1].tau3)
if (jets[0].tau1 != 0.0):
self.tree.fill('Jet1_tau31', jets[0].tau3 / jets[0].tau1)
self.tree.fill('Jet1_tau21', jets[0].tau2 / jets[0].tau1)
else:
self.tree.fill('Jet1_tau31', -99)
self.tree.fill('Jet1_tau21', -99)
if (jets[0].tau2 != 0.0):
self.tree.fill('Jet1_tau32', jets[0].tau3 / jets[0].tau2)
else:
self.tree.fill('Jet1_tau32', -99)
if (jets[1].tau1 != 0.0):
self.tree.fill('Jet2_tau31', jets[1].tau3 / jets[1].tau1)
self.tree.fill('Jet2_tau21', jets[1].tau2 / jets[1].tau1)
else:
self.tree.fill('Jet2_tau31', -99)
self.tree.fill('Jet2_tau21', -99)
if (jets[1].tau2 != 0.0):
self.tree.fill('Jet2_tau32', jets[1].tau3 / jets[1].tau2)
else:
self.tree.fill('Jet2_tau32', -99)
fillParticle(self.tree, 'Jet1', jets[0])
fillParticle(self.tree, 'Jet2', jets[1])
fillParticle(self.tree, 'softDroppedJet1',
jets[0].subjetsSoftDrop[0])
fillParticle(self.tree, 'softDroppedJet2',
jets[1].subjetsSoftDrop[0])
fillParticle(self.tree, 'trimmedJet1', jets[0].subjetsTrimming[0])
fillParticle(self.tree, 'trimmedJet2', jets[1].subjetsTrimming[0])
fillParticle(self.tree, 'prunedJet1', jets[0].subjetsPruning[0])
fillParticle(self.tree, 'prunedJet2', jets[1].subjetsPruning[0])
jet1_ungroomed = ROOT.TLorentzVector()
jet2_ungroomed = ROOT.TLorentzVector()
jet1_ungroomed.SetPtEtaPhiE(jets[0].pt(), jets[0].eta(),
jets[0].phi(), jets[0].e())
jet2_ungroomed.SetPtEtaPhiE(jets[1].pt(), jets[1].eta(),
jets[1].phi(), jets[1].e())
self.tree.fill('RSGravitonReconstructedMass',
(jet1_ungroomed + jet2_ungroomed).M())
jet1_trimmed = ROOT.TLorentzVector()
jet2_trimmed = ROOT.TLorentzVector()
jet1_trimmed.SetPtEtaPhiE(jets[0].subjetsTrimming[0].pt(),
jets[0].subjetsTrimming[0].eta(),
jets[0].subjetsTrimming[0].phi(),
jets[0].subjetsTrimming[0].e())
jet2_trimmed.SetPtEtaPhiE(jets[1].subjetsTrimming[0].pt(),
jets[1].subjetsTrimming[0].eta(),
jets[1].subjetsTrimming[0].phi(),
jets[1].subjetsTrimming[0].e())
self.tree.fill('RSGravitonReconstructedMass_trimmed',
(jet1_trimmed + jet2_trimmed).M())
jet1_pruned = ROOT.TLorentzVector()
jet2_pruned = ROOT.TLorentzVector()
jet1_pruned.SetPtEtaPhiE(jets[0].subjetsPruning[0].pt(),
jets[0].subjetsPruning[0].eta(),
jets[0].subjetsPruning[0].phi(),
jets[0].subjetsPruning[0].e())
jet2_pruned.SetPtEtaPhiE(jets[1].subjetsPruning[0].pt(),
jets[1].subjetsPruning[0].eta(),
jets[1].subjetsPruning[0].phi(),
jets[1].subjetsPruning[0].e())
self.tree.fill('RSGravitonReconstructedMass_pruned',
(jet1_pruned + jet2_pruned).M())
jet1_softDropped = ROOT.TLorentzVector()
jet2_softDropped = ROOT.TLorentzVector()
jet1_softDropped.SetPtEtaPhiE(jets[0].subjetsSoftDrop[0].pt(),
jets[0].subjetsSoftDrop[0].eta(),
jets[0].subjetsSoftDrop[0].phi(),
jets[0].subjetsSoftDrop[0].e())
jet2_softDropped.SetPtEtaPhiE(jets[1].subjetsSoftDrop[0].pt(),
jets[1].subjetsSoftDrop[0].eta(),
jets[1].subjetsSoftDrop[0].phi(),
jets[1].subjetsSoftDrop[0].e())
self.tree.fill('RSGravitonReconstructedMass_softDropped',
(jet1_softDropped + jet2_softDropped).M())
#Flow n,5
#############################################################################
#REQUIRES THE FOLLOWING IN heppy/analyzers/fcc/Reader.py AFTER LINE 151:
# particle_relations = defaultdict(list)
# for tjet in store.get(self.cfg_ana.fatjets):
# for i in range(tjet.particles_size()):
# particle_relations[Jet(tjet)].append(Particle(tjet.particles(i)))
# for fatjet, particles in particle_relations.items():
# fatjets[fatjet].jetConstituents = particles
#############################################################################
R_Jet1 = 4 * 100 / jets[0].pt()
R_Jet2 = 4 * 100 / jets[1].pt()
flow_Jet1 = [0] * 5
flow_Jet2 = [0] * 5
constituent_vector = ROOT.TLorentzVector()
for n in range(1, 5 + 1):
for constituent in jets[0].jetConstituents[1:]:
constituent_vector.SetPtEtaPhiE(constituent.pt(),
constituent.eta(),
constituent.phi(),
constituent.e())
dR = jet1_ungroomed.DeltaR(constituent_vector)
if ((dR >= (n - 1) / 5 * R_Jet1)
and (dR < n / 5 * R_Jet1)):
flow_Jet1[n - 1] += abs(constituent.pt()) / abs(
jets[0].pt())
for constituent in jets[1].jetConstituents[1:]:
constituent_vector.SetPtEtaPhiE(constituent.pt(),
constituent.eta(),
constituent.phi(),
constituent.e())
dR = jet2_ungroomed.DeltaR(constituent_vector)
if ((dR >= (n - 1) / 5 * R_Jet2)
and (dR < n / 5 * R_Jet2)):
flow_Jet2[n - 1] += abs(constituent.pt()) / abs(
jets[1].pt())
self.tree.fill('Jet1_Flow15', flow_Jet1[0])
self.tree.fill('Jet2_Flow15', flow_Jet2[0])
self.tree.fill('Jet1_Flow25', flow_Jet1[1])
self.tree.fill('Jet2_Flow25', flow_Jet2[1])
self.tree.fill('Jet1_Flow35', flow_Jet1[2])
self.tree.fill('Jet2_Flow35', flow_Jet2[2])
self.tree.fill('Jet1_Flow45', flow_Jet1[3])
self.tree.fill('Jet2_Flow45', flow_Jet2[3])
self.tree.fill('Jet1_Flow55', flow_Jet1[4])
self.tree.fill('Jet2_Flow55', flow_Jet2[4])
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
class TreeProducer(Analyzer):
def beginLoop(self, setup):
super(TreeProducer, self).beginLoop(setup)
self.rootfile = TFile('/'.join([self.dirName, 'tree.root']),
'recreate')
self.tree = Tree('events', '')
self.tree.var('weight', float)
self.tree.var('nljets', float)
self.tree.var('nbjets', float)
self.tree.var('njets', float)
self.tree.var('nlep', float)
bookParticle(self.tree, 'h1')
bookParticle(self.tree, 'h2')
bookParticle(self.tree, 'hh')
bookParticle(self.tree, 'b1')
bookParticle(self.tree, 'b2')
bookParticle(self.tree, 'b3')
bookParticle(self.tree, 'b4')
bookMet(self.tree, 'met')
self.reader = ROOT.TMVA.Reader()
self.bdt_b1_pt = array.array('f', [0])
self.bdt_b1_eta = array.array('f', [0])
self.bdt_b1_phi = array.array('f', [0])
self.bdt_b2_pt = array.array('f', [0])
self.bdt_b2_eta = array.array('f', [0])
self.bdt_b2_phi = array.array('f', [0])
self.bdt_b3_pt = array.array('f', [0])
self.bdt_b3_eta = array.array('f', [0])
self.bdt_b3_phi = array.array('f', [0])
self.bdt_b4_pt = array.array('f', [0])
self.bdt_b4_eta = array.array('f', [0])
self.bdt_b4_phi = array.array('f', [0])
self.bdt_h1_pt = array.array('f', [0])
self.bdt_h1_eta = array.array('f', [0])
self.bdt_h1_phi = array.array('f', [0])
self.bdt_h1_m = array.array('f', [0])
self.bdt_h2_pt = array.array('f', [0])
self.bdt_h2_eta = array.array('f', [0])
self.bdt_h2_phi = array.array('f', [0])
self.bdt_h2_m = array.array('f', [0])
self.bdt_hh_pt = array.array('f', [0])
self.bdt_hh_eta = array.array('f', [0])
self.bdt_hh_phi = array.array('f', [0])
self.bdt_hh_m = array.array('f', [0])
self.reader.AddVariable('b1_pt', self.bdt_b1_pt)
self.reader.AddVariable('b1_eta', self.bdt_b1_eta)
self.reader.AddVariable('b1_phi', self.bdt_b1_phi)
self.reader.AddVariable('b2_pt', self.bdt_b2_pt)
self.reader.AddVariable('b2_eta', self.bdt_b2_eta)
self.reader.AddVariable('b2_phi', self.bdt_b2_phi)
self.reader.AddVariable('b3_pt', self.bdt_b3_pt)
self.reader.AddVariable('b3_eta', self.bdt_b3_eta)
self.reader.AddVariable('b3_phi', self.bdt_b3_phi)
self.reader.AddVariable('b4_pt', self.bdt_b4_pt)
self.reader.AddVariable('b4_eta', self.bdt_b4_eta)
self.reader.AddVariable('b4_phi', self.bdt_b4_phi)
self.reader.AddVariable('h1_pt', self.bdt_h1_pt)
self.reader.AddVariable('h1_eta', self.bdt_h1_eta)
self.reader.AddVariable('h1_phi', self.bdt_h1_phi)
self.reader.AddVariable('h1_m', self.bdt_h1_m)
self.reader.AddVariable('h2_pt', self.bdt_h2_pt)
self.reader.AddVariable('h2_eta', self.bdt_h2_eta)
self.reader.AddVariable('h2_phi', self.bdt_h2_phi)
self.reader.AddVariable('h2_m', self.bdt_h2_m)
self.reader.AddVariable('hh_pt', self.bdt_hh_pt)
self.reader.AddVariable('hh_eta', self.bdt_hh_eta)
self.reader.AddVariable('hh_phi', self.bdt_hh_phi)
self.reader.AddVariable('hh_m', self.bdt_hh_m)
path = "/eos/user/s/selvaggi/Analysis/TMVA/hhbbbb_v3/lambda100_5f/weights/BDT_BDT_lambda100_5f.weights.xml"
self.reader.BookMVA("BDT", path)
self.tree.var('tmva_bdt', float)
def process(self, event):
self.tree.reset()
## these pairs contain overlap
hbbs = getattr(event, self.cfg_ana.hbbs)
bs = getattr(event, self.cfg_ana.bs)
hbbs.sort(key=lambda x: abs(x.m() - 125.))
if len(bs) > 3:
def bestHiggsPair(hbbs):
higgs_pairs = []
for p in hbbs:
p1 = p.leg1()
p2 = p.leg2()
for m in hbbs:
m1 = m.leg1()
m2 = m.leg2()
if m1 == p1 or m1 == p2 or m2 == p1 or m2 == p2:
continue
fillpair = True
for hp in higgs_pairs:
if m in hp and p in hp:
fillpair = False
if fillpair:
higgs_pairs.append((p, m))
higgs_pairs.sort(key=lambda x: abs(x[0].m() - x[1].m()))
return higgs_pairs[0]
higgs_pair = bestHiggsPair(hbbs)
self.tree.fill('weight', event.weight)
# jet multiplicities
self.tree.fill('nbjets', len(event.selected_bs))
self.tree.fill('nljets', len(event.selected_lights))
self.tree.fill('njets',
len(event.selected_lights) + len(event.selected_bs))
self.tree.fill('nlep', len(event.selected_leptons))
# missing Et
fillMet(self.tree, 'met', event.met)
#bs.sort(key=lambda x: x.pt(), reverse=True)
hh = Resonance(higgs_pair[0], higgs_pair[1], 25)
higgses = [higgs_pair[0], higgs_pair[1]]
higgses.sort(key=lambda x: x.pt(), reverse=True)
self.bdt_b1_pt[0] = bs[0].p4().Pt()
self.bdt_b1_eta[0] = bs[0].p4().Eta()
self.bdt_b1_phi[0] = bs[0].p4().Phi()
self.bdt_b2_pt[0] = bs[1].p4().Pt()
self.bdt_b2_eta[0] = bs[1].p4().Eta()
self.bdt_b2_phi[0] = bs[1].p4().Phi()
self.bdt_b3_pt[0] = bs[2].p4().Pt()
self.bdt_b3_eta[0] = bs[2].p4().Eta()
self.bdt_b3_phi[0] = bs[2].p4().Phi()
self.bdt_b4_pt[0] = bs[3].p4().Pt()
self.bdt_b4_eta[0] = bs[3].p4().Eta()
self.bdt_b4_phi[0] = bs[3].p4().Phi()
self.bdt_h1_pt[0] = higgses[0].p4().Pt()
self.bdt_h1_eta[0] = higgses[0].p4().Eta()
self.bdt_h1_phi[0] = higgses[0].p4().Phi()
self.bdt_h1_m[0] = higgses[0].p4().M()
self.bdt_h2_pt[0] = higgses[1].p4().Pt()
self.bdt_h2_eta[0] = higgses[1].p4().Eta()
self.bdt_h2_phi[0] = higgses[1].p4().Phi()
self.bdt_h2_m[0] = higgses[1].p4().M()
self.bdt_hh_pt[0] = hh.p4().Pt()
self.bdt_hh_eta[0] = hh.p4().Eta()
self.bdt_hh_phi[0] = hh.p4().Phi()
self.bdt_hh_m[0] = hh.p4().M()
mva_value = self.reader.EvaluateMVA("BDT")
print mva_value
fillParticle(self.tree, 'hh', hh)
fillParticle(self.tree, 'h1', higgses[0])
fillParticle(self.tree, 'h2', higgses[1])
fillParticle(self.tree, 'b1', bs[0])
fillParticle(self.tree, 'b2', bs[1])
fillParticle(self.tree, 'b3', bs[2])
fillParticle(self.tree, 'b4', bs[3])
self.tree.fill('tmva_bdt', mva_value)
self.tree.tree.Fill()
def write(self, setup):
self.rootfile.Write()
self.rootfile.Close()
