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()
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()
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()