def pad_and_flatten(val): import awkward as ak try: return ak.flatten(ak.fill_none(ak.pad_none(val, 1, clip=True), 0)) #return val.pad(1, clip=True).fillna(0.).flatten()#.reshape(-1, 1) except ValueError: return ak.flatten(val)
def combine(eff, sf): # tagged SF = SF*eff / eff = SF tagged_sf = awkward1.prod(sf[passbtag], axis=-1) # untagged SF = (1 - SF*eff) / (1 - eff) untagged_sf = awkward1.prod( ((1 - sf * eff) / (1 - eff))[~passbtag], axis=-1) return awkward1.fill_none(tagged_sf * untagged_sf, 1.) # TODO: move None guard to coffea
def globalindex(): gidx = awkward1.Array( awkward1.layout.ListOffsetArray32( awkward1.layout.Index32(source_offsets), index.generator(), ) ) gidx = gidx.mask[gidx >= 0] + target_offsets[:-1] return awkward1.fill_none(awkward1.flatten(gidx), -1)
def test_highlevel(): array = awkward1.Array([[1.1, 2.2, None, 3.3], [], [4.4, None, 5.5]]) assert awkward1.to_list(awkward1.fill_none(array, 999)) == [[1.1, 2.2, 999, 3.3], [], [4.4, 999, 5.5]] assert awkward1.to_list(awkward1.fill_none(array, [1, 2, 3])) == [[1.1, 2.2, [1, 2, 3], 3.3], [], [4.4, [1, 2, 3], 5.5]] assert awkward1.to_list(awkward1.fill_none(array, [])) == [[1.1, 2.2, [], 3.3], [], [4.4, [], 5.5]] assert awkward1.to_list(awkward1.fill_none(array, {"x": 999})) == [[1.1, 2.2, {"x": 999}, 3.3], [], [4.4, {"x": 999}, 5.5]] array = awkward1.Array([[1.1, 2.2, 3.3], None, [], None, [4.4, 5.5]]) assert awkward1.to_list(awkward1.fill_none(array, 999)) == [[1.1, 2.2, 3.3], 999, [], 999, [4.4, 5.5]] assert awkward1.to_list(awkward1.fill_none(array, [1, 2, 3])) == [[1.1, 2.2, 3.3], [1, 2, 3], [], [1, 2, 3], [4.4, 5.5]] assert awkward1.to_list(awkward1.fill_none(array, {"x": 999})) == [[1.1, 2.2, 3.3], {"x": 999}, [], {"x": 999}, [4.4, 5.5]] assert awkward1.to_list(awkward1.fill_none(array, [])) == [[1.1, 2.2, 3.3], [], [], [], [4.4, 5.5]]
def local2global(stack): """Turn jagged local index into global index Signature: index,target_offsets,!local2global Outputs a content array with same shape as index content """ target_offsets = stack.pop() index = stack.pop() index = index.mask[index >= 0] + target_offsets[:-1] out = numpy.array(awkward1.flatten(awkward1.fill_none(index, -1))) if out.dtype != numpy.int64: raise RuntimeError stack.append(out)
def matchJets(self, obj, jet, deltaRCut=0.4): combs = ak.cartesian([obj, jet], nested=True) jet_index = ak.local_index(delta_r( combs['0'], combs['1']))[delta_r(combs['0'], combs['1']) < 0.4] jet_index_pad = ak.flatten(ak.fill_none( ak.pad_none(jet_index, target=1, clip=True, axis=2), 0), axis=2) mask = ak.num(jet_index, axis=2) > 0 # a mask for obj with a matched jet mask_match = mask * 1 + ~mask * 0 mask_nomatch = mask * 0 + ~mask * 1 return jet_index_pad, mask_match, mask_nomatch
def process(self, events): output = self.accumulator.identity() # we can use a very loose preselection to filter the events. nothing is done with this presel, though presel = ak.num(events.Jet) > 0 ev = events[presel] dataset = ev.metadata['dataset'] # load the config - probably not needed anymore cfg = loadConfig() output['totalEvents']['all'] += len(events) output['skimmedEvents']['all'] += len(ev) ## Muons muon = ev.Muon ## Electrons electron = Collections(ev, "Electron", "tight").get() #electron = electron[(ak.nan_to_num(electron.eta, 99))] electron = electron[(electron.miniPFRelIso_all < 0.12) & (electron.pt > 20) & (abs(electron.eta) < 2.4)] gen_matched_electron = electron[((electron.genPartIdx >= 0) & (abs( electron.matched_gen.pdgId) == 11))] is_flipped = ((gen_matched_electron.matched_gen.pdgId * (-1) == gen_matched_electron.pdgId) & (abs(gen_matched_electron.pdgId) == 11)) #(abs(ev.GenPart[gen_matched_electron.genPartIdx].pdgId) ==abs(gen_matched_electron.pdgId))&(ev.GenPart[gen_matched_electron.genPartIdx].pdgId/abs(ev.GenPart[gen_matched_electron.genPartIdx].pdgId) != gen_matched_electron.pdgId/abs(gen_matched_electron.pdgId)) flipped_electron = gen_matched_electron[is_flipped] flipped_electron = flipped_electron[(ak.fill_none( flipped_electron.pt, 0) > 0)] n_flips = ak.num(flipped_electron) dielectron = choose(electron, 2) SSelectron = ak.any( (dielectron['0'].charge * dielectron['1'].charge) > 0, axis=1) leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1)) leading_electron = electron[leading_electron_idx] leading_flipped_electron_idx = ak.singletons( ak.argmax(flipped_electron.pt, axis=1)) leading_flipped_electron = electron[leading_flipped_electron_idx] ## MET -> can switch to puppi MET met_pt = ev.MET.pt met_phi = ev.MET.phi # setting up the various weights weight = Weights(len(ev)) if not dataset == 'MuonEG': # generator weight weight.add("weight", ev.genWeight) #selections filters = getFilters(ev, year=self.year, dataset=dataset) electr = ((ak.num(electron) >= 1)) gen_electr = ((ak.num(gen_matched_electron) >= 1)) ss = (SSelectron) flip = (n_flips >= 1) selection = PackedSelection() selection.add('filter', (filters)) selection.add('electr', electr) selection.add('ss', ss) selection.add('flip', flip) selection.add('gen_electr', gen_electr) bl_reqs = ['filter', 'electr', 'gen_electr'] bl_reqs_d = {sel: True for sel in bl_reqs} baseline = selection.require(**bl_reqs_d) f_reqs = bl_reqs + ['flip'] f_reqs_d = {sel: True for sel in f_reqs} flip_sel = selection.require(**f_reqs_d) #adjust weights to prevent length mismatch ak_weight_gen = ak.ones_like( gen_matched_electron[baseline].pt) * weight.weight()[baseline] ak_weight_flip = ak.ones_like( flipped_electron[flip_sel].pt) * weight.weight()[flip_sel] output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(electron)[baseline], weight=weight.weight()[baseline]) output['electron_flips'].fill(dataset=dataset, multiplicity=n_flips[baseline], weight=weight.weight()[baseline]) output["electron"].fill( dataset=dataset, pt=ak.to_numpy(ak.flatten(gen_matched_electron[baseline].pt)), eta=abs(ak.to_numpy(ak.flatten( gen_matched_electron[baseline].eta))), #phi = ak.to_numpy(ak.flatten(leading_electron[baseline].phi)), #weight = ak.to_numpy(ak.flatten(ak_weight_gen)) ) output["electron2"].fill( dataset=dataset, pt=ak.to_numpy(ak.flatten(gen_matched_electron[baseline].pt)), eta=ak.to_numpy(ak.flatten(gen_matched_electron[baseline].eta)), #phi = ak.to_numpy(ak.flatten(leading_electron[baseline].phi)), #weight = ak.to_numpy(ak.flatten(ak_weight_gen)) ) output["flipped_electron"].fill( dataset=dataset, pt=ak.to_numpy(ak.flatten(flipped_electron[flip_sel].pt)), eta=abs(ak.to_numpy(ak.flatten(flipped_electron[flip_sel].eta))), #phi = ak.to_numpy(ak.flatten(flipped_electron[flip_sel].phi)), #weight = ak.to_numpy(ak.flatten(ak_weight_flip)) ) output["flipped_electron2"].fill( dataset=dataset, pt=ak.to_numpy(ak.flatten(flipped_electron[flip_sel].pt)), eta=ak.to_numpy(ak.flatten(flipped_electron[flip_sel].eta)), #phi = ak.to_numpy(ak.flatten(flipped_electron[flip_sel].phi)), #weight = ak.to_numpy(ak.flatten(ak_weight_flip)) ) return output
def process(self, events): output = self.accumulator.identity() # we can use a very loose preselection to filter the events. nothing is done with this presel, though presel = ak.num(events.Jet)>=2 ev = events[presel] dataset = ev.metadata['dataset'] # load the config - probably not needed anymore cfg = loadConfig() output['totalEvents']['all'] += len(events) output['skimmedEvents']['all'] += len(ev) ## Electrons electron = Collections(ev, "Electron", "tightFCNC", 0, self.year).get() electron = electron[(electron.pt > 15) & (np.abs(electron.eta) < 2.4)] electron = electron[(electron.genPartIdx >= 0)] electron = electron[(np.abs(electron.matched_gen.pdgId)==11)] #from here on all leptons are gen-matched electron = electron[( (electron.genPartFlav==1) | (electron.genPartFlav==15) )] #and now they are all prompt leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1)) leading_electron = electron[leading_electron_idx] trailing_electron_idx = ak.singletons(ak.argmin(electron.pt, axis=1)) trailing_electron = electron[trailing_electron_idx] leading_parent = find_first_parent(leading_electron.matched_gen) trailing_parent = find_first_parent(trailing_electron.matched_gen) is_flipped = ( ( (electron.matched_gen.pdgId*(-1) == electron.pdgId) | (find_first_parent(electron.matched_gen)*(-1) == electron.pdgId) ) & (np.abs(electron.pdgId) == 11) ) flipped_electron = electron[is_flipped] flipped_electron = flipped_electron[(ak.fill_none(flipped_electron.pt, 0)>0)] flipped_electron = flipped_electron[~(ak.is_none(flipped_electron))] n_flips = ak.num(flipped_electron) ##Muons muon = Collections(ev, "Muon", "tightFCNC").get() muon = muon[(muon.pt > 15) & (np.abs(muon.eta) < 2.4)] muon = muon[(muon.genPartIdx >= 0)] muon = muon[(np.abs(muon.matched_gen.pdgId)==13)] #from here, all muons are gen-matched muon = muon[( (muon.genPartFlav==1) | (muon.genPartFlav==15) )] #and now they are all prompt ##Leptons lepton = ak.concatenate([muon, electron], axis=1) SSlepton = (ak.sum(lepton.charge, axis=1) != 0) & (ak.num(lepton)==2) OSlepton = (ak.sum(lepton.charge, axis=1) == 0) & (ak.num(lepton)==2) emulepton = (ak.num(electron) == 1) & (ak.num(muon) == 1) no_mumu = (ak.num(muon) <= 1) leading_lepton_idx = ak.singletons(ak.argmax(lepton.pt, axis=1)) leading_lepton = lepton[leading_lepton_idx] trailing_lepton_idx = ak.singletons(ak.argmin(lepton.pt, axis=1)) trailing_lepton = lepton[trailing_lepton_idx] #jets jet = getJets(ev, minPt=40, maxEta=2.4, pt_var='pt') jet = jet[ak.argsort(jet.pt, ascending=False)] # need to sort wrt smeared and recorrected jet pt jet = jet[~match(jet, muon, deltaRCut=0.4)] # remove jets that overlap with muons jet = jet[~match(jet, electron, deltaRCut=0.4)] ## MET -> can switch to puppi MET met_pt = ev.MET.pt met_phi = ev.MET.phi # setting up the various weights weight = Weights( len(ev) ) weight2 = Weights( len(ev)) if not dataset=='MuonEG': # generator weight weight.add("weight", ev.genWeight) weight2.add("weight", ev.genWeight) weight2.add("charge flip", self.charge_flip_ratio.flip_weight(electron)) #selections filters = getFilters(ev, year=self.year, dataset=dataset) ss = (SSlepton) os = (OSlepton) jet_all = (ak.num(jet) >= 2) diele = (ak.num(electron) == 2) emu = (emulepton) flips = (n_flips == 1) no_flips = (n_flips == 0) nmm = no_mumu selection = PackedSelection() selection.add('filter', (filters) ) selection.add('ss', ss ) selection.add('os', os ) selection.add('jet', jet_all ) selection.add('ee', diele) selection.add('emu', emu) selection.add('flip', flips) selection.add('nflip', no_flips) selection.add('no_mumu', nmm) bl_reqs = ['filter'] + ['jet'] bl_reqs_d = { sel: True for sel in bl_reqs } baseline = selection.require(**bl_reqs_d) f_reqs = bl_reqs + ['flip'] + ['ss'] + ['ee'] f_reqs_d = {sel: True for sel in f_reqs} flip_sel = selection.require(**f_reqs_d) f2_reqs = bl_reqs + ['flip'] + ['ss'] + ['emu'] f2_reqs_d = {sel: True for sel in f2_reqs} flip_sel2 = selection.require(**f2_reqs_d) f3_reqs = bl_reqs + ['flip'] + ['ss'] + ['no_mumu'] f3_reqs_d = {sel: True for sel in f3_reqs} flip_sel3 = selection.require(**f3_reqs_d) nf_reqs = bl_reqs + ['nflip'] + ['os'] + ['ee'] nf_reqs_d = {sel: True for sel in nf_reqs} n_flip_sel = selection.require(**nf_reqs_d) nf2_reqs = bl_reqs + ['nflip'] + ['os'] + ['emu'] nf2_reqs_d = {sel: True for sel in nf2_reqs} n_flip_sel2 = selection.require(**nf2_reqs_d) nf3_reqs = bl_reqs + ['nflip'] + ['os'] + ['no_mumu'] nf3_reqs_d = {sel: True for sel in nf3_reqs} n_flip_sel3 = selection.require(**nf3_reqs_d) s_reqs = bl_reqs + ['ss'] + ['no_mumu'] s_reqs_d = { sel: True for sel in s_reqs } ss_sel = selection.require(**s_reqs_d) o_reqs = bl_reqs + ['os'] + ['no_mumu'] o_reqs_d = {sel: True for sel in o_reqs } os_sel = selection.require(**o_reqs_d) ees_reqs = bl_reqs + ['ss'] + ['ee'] ees_reqs_d = { sel: True for sel in ees_reqs } eess_sel = selection.require(**ees_reqs_d) eeo_reqs = bl_reqs + ['os'] + ['ee'] eeo_reqs_d = {sel: True for sel in eeo_reqs } eeos_sel = selection.require(**eeo_reqs_d) ems_reqs = bl_reqs + ['ss'] + ['emu'] ems_reqs_d = { sel: True for sel in ems_reqs } emss_sel = selection.require(**ems_reqs_d) emo_reqs = bl_reqs + ['os'] + ['emu'] emo_reqs_d = {sel: True for sel in emo_reqs } emos_sel = selection.require(**emo_reqs_d) #outputs output['N_jet'].fill(dataset=dataset, multiplicity=ak.num(jet)[baseline], weight=weight.weight()[baseline]) output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(lepton)[ss_sel], weight=weight.weight()[ss_sel]) output['N_ele2'].fill(dataset=dataset, multiplicity=ak.num(lepton)[os_sel], weight=weight2.weight()[os_sel]) output['electron_flips'].fill(dataset=dataset, multiplicity = n_flips[flip_sel], weight=weight.weight()[flip_sel]) output['electron_flips2'].fill(dataset=dataset, multiplicity = n_flips[n_flip_sel], weight=weight2.weight()[n_flip_sel]) output['electron_flips3'].fill(dataset=dataset, multiplicity = n_flips[flip_sel2], weight=weight.weight()[flip_sel2]) output['electron_flips4'].fill(dataset=dataset, multiplicity = n_flips[n_flip_sel2], weight=weight2.weight()[n_flip_sel2]) output["electron"].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_electron[flip_sel3].pt)), eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[flip_sel3].eta))), weight = weight.weight()[flip_sel3] ) output["electron2"].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_electron[n_flip_sel3].pt)), eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[n_flip_sel3].eta))), weight = weight2.weight()[n_flip_sel3] ) output["flipped_electron"].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_electron[flip_sel].pt)), eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[flip_sel].eta))), weight = weight.weight()[flip_sel] ) output["flipped_electron2"].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_electron[n_flip_sel].pt)), eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[n_flip_sel].eta))), weight = weight2.weight()[n_flip_sel] ) output["flipped_electron3"].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_electron[flip_sel2].pt)), eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[flip_sel2].eta))), weight = weight.weight()[flip_sel2] ) output["flipped_electron4"].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_electron[n_flip_sel2].pt)), eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[n_flip_sel2].eta))), weight = weight2.weight()[n_flip_sel2] ) #output["lepton_parent"].fill( # dataset = dataset, # pdgID = np.abs(ak.to_numpy(ak.flatten(leading_parent[ss_sel]))), # weight = weight.weight()[ss_sel] #) # #output["lepton_parent2"].fill( # dataset = dataset, # pdgID = np.abs(ak.to_numpy(ak.flatten(trailing_parent[ss_sel]))), # weight = weight.weight()[ss_sel] #) return output
def process(self, events): dataset = events.metadata['dataset'] isRealData = not hasattr(events, "genWeight") selection = PackedSelection() weights = Weights(len(events)) output = self.accumulator.identity() if not isRealData: output['sumw'][dataset] += ak.sum(events.genWeight) if isRealData: trigger = np.zeros(len(events), dtype='bool') for t in self._triggers[self._year]: trigger = trigger | events.HLT[t] else: trigger = np.ones(len(events), dtype='bool') selection.add('trigger', trigger) if isRealData: trigger = np.zeros(len(events), dtype='bool') for t in self._muontriggers[self._year]: trigger = trigger | events.HLT[t] else: trigger = np.ones(len(events), dtype='bool') selection.add('muontrigger', trigger) fatjets = events.FatJet fatjets['msdcorr'] = corrected_msoftdrop(fatjets) fatjets['qcdrho'] = 2 * np.log(fatjets.msdcorr / fatjets.pt) fatjets['n2ddt'] = fatjets.n2b1 - n2ddt_shift(fatjets, year=self._year) fatjets['msdcorr_full'] = fatjets['msdcorr'] * self._msdSF[self._year] candidatejet = fatjets[ # https://github.com/DAZSLE/BaconAnalyzer/blob/master/Analyzer/src/VJetLoader.cc#L269 (fatjets.pt > 200) & (abs(fatjets.eta) < 2.5) & fatjets.isTight # this is loose in sampleContainer ] if self._jet_arbitration == 'pt': candidatejet = ak.firsts(candidatejet) elif self._jet_arbitration == 'mass': candidatejet = candidatejet[ak.argmax(candidatejet.msdcorr)] elif self._jet_arbitration == 'n2': candidatejet = candidatejet[ak.argmin(candidatejet.n2ddt)] elif self._jet_arbitration == 'ddb': candidatejet = candidatejet[ak.argmax(candidatejet.btagDDBvL)] else: raise RuntimeError("Unknown candidate jet arbitration") selection.add('minjetkin', (candidatejet.pt >= 450) & (candidatejet.msdcorr >= 40.) & (abs(candidatejet.eta) < 2.5)) selection.add('jetacceptance', (candidatejet.msdcorr >= 47.) & (candidatejet.pt < 1200) & (candidatejet.msdcorr < 201.)) selection.add('jetid', candidatejet.isTight) selection.add('n2ddt', (candidatejet.n2ddt < 0.)) selection.add('ddbpass', (candidatejet.btagDDBvL >= 0.89)) jets = events.Jet[(events.Jet.pt > 30.) & (abs(events.Jet.eta) < 2.5) & events.Jet.isTight] # only consider first 4 jets to be consistent with old framework jets = jets[:, :4] dphi = abs(jets.delta_phi(candidatejet)) selection.add( 'antiak4btagMediumOppHem', ak.max( jets[dphi > np.pi / 2].btagDeepB, axis=1, mask_identity=False) < BTagEfficiency.btagWPs[self._year]['medium']) ak4_away = jets[dphi > 0.8] selection.add( 'ak4btagMedium08', ak.max(ak4_away.btagDeepB, axis=1, mask_identity=False) > BTagEfficiency.btagWPs[self._year]['medium']) selection.add('met', events.MET.pt < 140.) goodmuon = ((events.Muon.pt > 10) & (abs(events.Muon.eta) < 2.4) & (events.Muon.pfRelIso04_all < 0.25) & events.Muon.looseId) nmuons = ak.sum(goodmuon, axis=1) leadingmuon = ak.firsts(events.Muon[goodmuon]) nelectrons = ak.sum( (events.Electron.pt > 10) & (abs(events.Electron.eta) < 2.5) & (events.Electron.cutBased >= events.Electron.LOOSE), axis=1, ) ntaus = ak.sum( (events.Tau.pt > 20) & events.Tau.idDecayMode, # bacon iso looser than Nano selection axis=1, ) selection.add('noleptons', (nmuons == 0) & (nelectrons == 0) & (ntaus == 0)) selection.add('onemuon', (nmuons == 1) & (nelectrons == 0) & (ntaus == 0)) selection.add('muonkin', (leadingmuon.pt > 55.) & (abs(leadingmuon.eta) < 2.1)) selection.add('muonDphiAK8', abs(leadingmuon.delta_phi(candidatejet)) > 2 * np.pi / 3) if isRealData: genflavor = 0 else: weights.add('genweight', events.genWeight) add_pileup_weight(weights, events.Pileup.nPU, self._year, dataset) bosons = getBosons(events.GenPart) matchedBoson = candidatejet.nearest(bosons, axis=None, threshold=0.8) genflavor = bosonFlavor(matchedBoson) genBosonPt = ak.fill_none(ak.firsts(bosons.pt), 0) add_VJets_NLOkFactor(weights, genBosonPt, self._year, dataset) add_jetTriggerWeight(weights, candidatejet.msdcorr, candidatejet.pt, self._year) output['btagWeight'].fill(dataset=dataset, val=self._btagSF.addBtagWeight( weights, ak4_away)) logger.debug("Weight statistics: %r" % weights.weightStatistics) msd_matched = candidatejet.msdcorr * self._msdSF[self._year] * ( genflavor > 0) + candidatejet.msdcorr * (genflavor == 0) regions = { 'signal': [ 'trigger', 'minjetkin', 'jetacceptance', 'jetid', 'n2ddt', 'antiak4btagMediumOppHem', 'met', 'noleptons' ], 'muoncontrol': [ 'muontrigger', 'minjetkin', 'jetacceptance', 'jetid', 'n2ddt', 'ak4btagMedium08', 'onemuon', 'muonkin', 'muonDphiAK8' ], 'noselection': [], } for region, cuts in regions.items(): allcuts = set() output['cutflow'].fill(dataset=dataset, region=region, genflavor=genflavor, cut=0, weight=weights.weight()) for i, cut in enumerate(cuts + ['ddbpass']): allcuts.add(cut) cut = selection.all(*allcuts) output['cutflow'].fill(dataset=dataset, region=region, genflavor=genflavor[cut], cut=i + 1, weight=weights.weight()[cut]) systematics = [ None, 'jet_triggerUp', 'jet_triggerDown', 'btagWeightUp', 'btagWeightDown', 'btagEffStatUp', 'btagEffStatDown', ] def normalize(val, cut): return ak.to_numpy(ak.fill_none(val[cut], np.nan)) def fill(region, systematic, wmod=None): selections = regions[region] cut = selection.all(*selections) sname = 'nominal' if systematic is None else systematic if wmod is None: weight = weights.weight(modifier=systematic)[cut] else: weight = weights.weight()[cut] * wmod[cut] output['templates'].fill( dataset=dataset, region=region, systematic=sname, genflavor=genflavor[cut], pt=normalize(candidatejet.pt, cut), msd=normalize(msd_matched, cut), ddb=normalize(candidatejet.btagDDBvL, cut), weight=weight, ) if wmod is not None: output['genresponse_noweight'].fill( dataset=dataset, region=region, systematic=sname, pt=normalize(candidatejet.pt, cut), genpt=normalize(genBosonPt, cut), weight=events.genWeight[cut] * wmod[cut], ) output['genresponse'].fill( dataset=dataset, region=region, systematic=sname, pt=normalize(candidatejet.pt, cut), genpt=normalize(genBosonPt, cut), weight=weight, ) for region in regions: cut = selection.all(*(set(regions[region]) - {'n2ddt'})) output['nminus1_n2ddt'].fill( dataset=dataset, region=region, n2ddt=normalize(candidatejet.n2ddt, cut), weight=weights.weight()[cut], ) for systematic in systematics: fill(region, systematic) if 'GluGluHToBB' in dataset: for i in range(9): fill(region, 'LHEScale_%d' % i, events.LHEScaleWeight[:, i]) for c in events.LHEWeight.columns[1:]: fill(region, 'LHEWeight_%s' % c, events.LHEWeight[c]) output["weightStats"] = weights.weightStatistics return output
def __init__(self, ev, obj, wp, year=2018, verbose=0): self.obj = obj self.wp = wp if self.wp == None: self.selection_dict = {} else: self.selection_dict = obj_def[self.obj][self.wp] self.v = verbose self.year = year id_level = None if wp.lower().count('veto'): id_level = 0 elif wp.lower().count('fake'): id_level = 1 elif wp.lower().count('tight'): id_level = 2 if self.obj == "Muon": # collections are already there, so we just need to calculate missing ones ev['Muon', 'absMiniIso'] = ev.Muon.miniPFRelIso_all * ev.Muon.pt ev['Muon', 'ptErrRel'] = ev.Muon.ptErr / ev.Muon.pt # this is what we are using: # - jetRelIso if the matched jet is within deltaR<0.4, pfRelIso03_all otherwise # - btagDeepFlavB discriminator of the matched jet if jet is within deltaR<0.4, 0 otherwise # - pt_cone = 0.9*pt of matched jet if jet is within deltaR<0.4, pt/(pt+iso) otherwise mask_close = (ak.fill_none(ev.Muon.delta_r(ev.Muon.matched_jet), 99) < 0.4) * 1 mask_far = ~(ak.fill_none(ev.Muon.delta_r(ev.Muon.matched_jet), 99) < 0.4) * 1 deepJet = ak.fill_none(ev.Muon.matched_jet.btagDeepFlavB, 0) * mask_close + 0 * mask_far jetRelIsoV2 = ev.Muon.jetRelIso * mask_close + ev.Muon.pfRelIso03_all * mask_far # default to 0 if no match conePt = 0.9 * ak.fill_none( ev.Muon.matched_jet.pt, 0) * mask_close + (ev.Muon.pt * (1 + ev.Muon.miniPFRelIso_all)) * mask_far #conePt = 0.8 * ak.fill_none(ev.Muon.matched_jet.pt,0) * mask_close + (ev.Muon.pt/(1 + ev.Muon.miniPFRelIso_all))*mask_far ev['Muon', 'deepJet'] = ak.copy(deepJet) ev['Muon', 'jetRelIsoV2'] = jetRelIsoV2 ev['Muon', 'conePt'] = conePt ev['Muon', 'id'] = ak.ones_like(conePt) * id_level self.cand = ev.Muon elif self.obj == "Electron": # calculate new variables. asignment is awkward, but what can you do. ev['Electron', 'absMiniIso'] = ev.Electron.miniPFRelIso_all * ev.Electron.pt ev['Electron', 'etaSC'] = ev.Electron.eta + ev.Electron.deltaEtaSC # the following line is only needed if we do our own matching. # right now, we keep using the NanoAOD match, but check the deltaR distance # jet_index, mask_match, mask_nomatch = self.matchJets(ev.Electron, ev.Jet) # this is what we are using: # - jetRelIso if the matched jet is within deltaR<0.4, pfRelIso03_all otherwise # - btagDeepFlavB discriminator of the matched jet if jet is within deltaR<0.4, 0 otherwise # - pt_cone = 0.9*pt of matched jet if jet is within deltaR<0.4, pt/(pt+iso) otherwise mask_close = (ak.fill_none( ev.Electron.delta_r(ev.Electron.matched_jet), 99) < 0.4) * 1 mask_far = ~(ak.fill_none( ev.Electron.delta_r(ev.Electron.matched_jet), 99) < 0.4) * 1 deepJet = ak.fill_none(ev.Electron.matched_jet.btagDeepFlavB, 0) * mask_close jetRelIsoV2 = ev.Electron.jetRelIso * mask_close + ev.Electron.pfRelIso03_all * mask_far # default to 0 if no match conePt = 0.9 * ak.fill_none( ev.Electron.matched_jet.pt, 0) * mask_close + ( ev.Electron.pt * (1 + ev.Electron.miniPFRelIso_all)) * mask_far #conePt = 0.8 * ak.fill_none(ev.Electron.matched_jet.pt,0) * mask_close + (ev.Electron.pt/(1 + ev.Electron.miniPFRelIso_all))*mask_far ev['Electron', 'deepJet'] = ak.copy(deepJet) ev['Electron', 'jetRelIsoV2'] = jetRelIsoV2 ev['Electron', 'conePt'] = conePt ev['Electron', 'id'] = ak.ones_like(conePt) * id_level self.cand = ev.Electron self.getSelection() if self.obj == "Electron" and self.wp == "tight": self.selection = self.selection & self.getElectronMVAID( ) & self.getIsolation(0.07, 0.78, 8.0) & self.isTriggerSafeNoIso() if self.v > 0: print(" - custom ID and multi-isolation") if self.obj == "Muon" and self.wp == "tight": self.selection = self.selection & self.getIsolation( 0.11, 0.74, 6.8) if self.v > 0: print(" - custom multi-isolation") #self.selection = self.selection & ak.fill_none(ev.Muon.matched_jet.btagDeepFlavB<0.2770, True) #self.selection = self.selection & (ev.Muon.matched_jet.btagDeepFlavB<0.2770) #if self.v>0: print (" - deepJet") if self.obj == "Electron" and (self.wp == "tightTTH" or self.wp == 'fakeableTTH' or self.wp == "tightSSTTH" or self.wp == 'fakeableSSTTH'): self.selection = self.selection & self.getSigmaIEtaIEta() if self.v > 0: print(" - SigmaIEtaIEta") #self.selection = self.selection & ak.fill_none(ev.Electron.matched_jet.btagDeepFlavB<0.2770, True) #self.selection = self.selection & (ev.Electron.matched_jet.btagDeepFlavB<0.2770) #self.selection = self.selection & (ev.Jet[ev.Electron.jetIdx].btagDeepFlavB<0.2770) #if self.v>0: print (" - deepJet") if self.obj == 'Muon' and (self.wp == 'fakeableTTH' or self.wp == 'fakeableSSTTH'): #self.selection = self.selection & (self.cand.deepJet < self.getThreshold(self.cand.conePt, min_pt=20, max_pt=45, low=0.2770, high=0.0494)) self.selection = self.selection & (ak.fill_none( ev.Muon.matched_jet.btagDeepFlavB, 0) < self.getThreshold( self.cand.conePt, min_pt=20, max_pt=45)) if self.v > 0: print(" - interpolated deepJet")
def bosonFlavor(bosons): childid = abs(bosons.children.pdgId) genflavor = ak.any(childid == 5, axis=-1) * 3 + ak.any( childid == 4, axis=-1) * 2 + ak.any(childid < 4, axis=-1) * 1 return ak.fill_none(genflavor, 0)
def process(self, events): output = self._accumulator.identity() dataset_name = events.metadata['dataset'] output["total_events"][dataset_name] += events.__len__() # Initialize dict accumulators, if have not been initialized for jet in [0, 1, 2]: if dataset_name not in output[f"eta_{jet}_final"].keys(): output[f"eta_{jet}_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"ptoverM_{jet}_final"].keys(): output[f"ptoverM_{jet}_final"][dataset_name] = processor.column_accumulator(np.array([])) for pair in [(0, 1), (1, 2), (2, 0)]: if dataset_name not in output[f"dEta_{pair[0]}{pair[1]}_final"].keys(): output[f"dEta_{pair[0]}{pair[1]}_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dR_{pair[0]}{pair[1]}_final"].keys(): output[f"dR_{pair[0]}{pair[1]}_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"moverM_{pair[0]}{pair[1]}_final"].keys(): output[f"moverM_{pair[0]}{pair[1]}_final"][dataset_name] = processor.column_accumulator(np.array([])) for pair in [(0, 1, 2), (1, 2, 0), (2, 0, 1)]: if dataset_name not in output[f"dR_{pair[0]}_{pair[1]}{pair[2]}_final"].keys(): output[f"dR_{pair[0]}_{pair[1]}{pair[2]}_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dEta_{pair[0]}_{pair[1]}{pair[2]}_final"].keys(): output[f"dEta_{pair[0]}_{pair[1]}{pair[2]}_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"Phi_{pair[0]}_{pair[1]}{pair[2]}_final"].keys(): output[f"Phi_{pair[0]}_{pair[1]}{pair[2]}_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dPtoverM_{pair[0]}_{pair[1]}{pair[2]}_final"].keys(): output[f"dPtoverM_{pair[0]}_{pair[1]}{pair[2]}_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"ptoverM_max_final"].keys(): output[f"ptoverM_max_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"ptoverM_min_final"].keys(): output[f"ptoverM_min_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"eta_max_final"].keys(): output[f"eta_max_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dR_max_final"].keys(): output[f"dR_max_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dR_min_final"].keys(): output[f"dR_min_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dEta_max_final"].keys(): output[f"dEta_max_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dEta_min_final"].keys(): output[f"dEta_min_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dR_j_jj_max_final"].keys(): output[f"dR_j_jj_max_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dR_j_jj_min_final"].keys(): output[f"dR_j_jj_min_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dEta_j_jj_max_final"].keys(): output[f"dEta_j_jj_max_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dEta_j_jj_min_final"].keys(): output[f"dEta_j_jj_min_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dPhi_j_jj_max_final"].keys(): output[f"dPhi_j_jj_max_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dPhi_j_jj_min_final"].keys(): output[f"dPhi_j_jj_min_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dPtoverM_j_jj_max_final"].keys(): output[f"dPtoverM_j_jj_max_final"][dataset_name] = processor.column_accumulator(np.array([])) if dataset_name not in output[f"dPtoverM_j_jj_min_final"].keys(): output[f"dPtoverM_j_jj_min_final"][dataset_name] = processor.column_accumulator(np.array([])) # HLT selection HLT_mask = [] if year == "2016": if "SingleMuon" in dataset_name: #this does not work, as the name of file which is under processing is unknown if "2016B2" in dataset_name: HLT_mask = events.HLT.IsoMu24 | events.HLT.IsoTkMu24 | events.HLT.Mu50 else: HLT_mask = events.HLT.IsoMu24 | events.HLT.IsoTkMu24 | events.HLT.Mu50 | events.HLT.TkMu50 else: #https://twiki.cern.ch/twiki/bin/view/CMS/HLTPathsRunIIList if "2016B2" in dataset_name: HLT_mask = events.HLT.PFHT800 | events.HLT.PFHT900 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID elif "2016H" in dataset_name: HLT_mask = events.HLT.PFHT900 | events.HLT.AK8PFJet450 | events.HLT.AK8PFJet500 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID else: HLT_mask = events.HLT.PFHT800 | events.HLT.PFHT900 | events.HLT.AK8PFJet450 | events.HLT.AK8PFJet500 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID if year == "2017": if "SingleMuon" in dataset_name: if "2017B" in dataset_name: HLT_mask = events.HLT.IsoMu27 | events.HLT.Mu50 else: HLT_mask = events.HLT.IsoMu27 | events.HLT.Mu50 | events.HLT.OldMu100 | events.HLT.TkMu100 else: HLT_mask = events.HLT.PFHT1050 | events.HLT.AK8PFJet500 | events.HLT.AK8PFJet550 | events.HLT.CaloJet500_NoJetID | events.HLT.CaloJet550_NoJetID | events.HLT.PFJet500 if year == "2018": if "SingleMuon" in dataset_name: HLT_mask = events.HLT.IsoMu24 | events.HLT.Mu50 | events.HLT.OldMu100 | events.HLT.TkMu100 else: HLT_mask = events.HLT.PFHT1050 | events.HLT.AK8PFJet500 | events.HLT.AK8PFJet550 | events.HLT.CaloJet500_NoJetID | events.HLT.CaloJet550_NoJetID | events.HLT.PFJet500 # Require 3 jets jet_mask = (events.Jet.pt > 30.) & (abs(events.Jet.eta) < 2.5) & (events.Jet.isTight) event_mask = (awk.sum(jet_mask, axis=1) >= 3) event_mask = event_mask & HLT_mask events_3j = events[event_mask] # Reduce jet mask to only events with 3 good jets jet_mask = jet_mask[event_mask] # Array of the jets to consider for trijet resonance selected_jets = events_3j.Jet[jet_mask][:, :3] # Pairs of jets #pairs = awk.argcombinations(selected_jets, 2) #jet_i, jet_j = awk.unzip(pairs) pairs = [(0, 1), (1, 2), (2, 0)] jet_i, jet_j = zip(*pairs) # Returns [0, 1, 2] , [1, 2, 0] m_ij = (selected_jets[:, jet_i] + selected_jets[:, jet_j]).mass dR_ij = selected_jets[:, jet_i].delta_r(selected_jets[:, jet_j]) dEta_ij = abs(selected_jets[:, jet_i].eta - selected_jets[:, jet_j].eta) jet_k = [2, 0, 1] dR_i_jk = selected_jets[:, jet_i].delta_r(selected_jets[:, jet_j] + selected_jets[:, jet_k]) dEta_i_jk = abs(selected_jets[:, jet_i].eta - (selected_jets[:, jet_j] + selected_jets[:, jet_k]).eta) dPhi_i_jk = abs(selected_jets[:, jet_i].phi - (selected_jets[:, jet_j] + selected_jets[:, jet_k]).phi) m3j = selected_jets.sum().mass pt_i_overM = selected_jets.pt / m3j m_01_overM = m_ij[:,0] / m3j m_12_overM = m_ij[:,1] / m3j m_20_overM = m_ij[:,2] / m3j dPtoverM_0_12 = abs(selected_jets[:, 0].pt - (selected_jets[:, 1] + selected_jets[:, 2]).pt) / m3j dPtoverM_1_20 = abs(selected_jets[:, 1].pt - (selected_jets[:, 2] + selected_jets[:, 0]).pt) / m3j dPtoverM_2_01 = abs(selected_jets[:, 2].pt - (selected_jets[:, 0] + selected_jets[:, 1]).pt) / m3j # Event selection masks # selection_masks = {} # Pre-selection selection = PackedSelection() selection.add("Dummy", m3j > 000) sel_mask = selection.require(**{name: True for name in selection.names}) # selection_masks["Pre-selection"] = sel_mask output["selected_events"][dataset_name] += events_3j[sel_mask].__len__() for jet in [0, 1, 2]: output[f"eta_{jet}_final"][dataset_name] += processor.column_accumulator(np.array(selected_jets[:, jet][sel_mask].eta)) output[f"ptoverM_{jet}_final"][dataset_name] += processor.column_accumulator(np.array(pt_i_overM[:, jet][sel_mask])) for pair in [(0, 1), (1, 2), (2, 0)]: output[f"dEta_{pair[0]}{pair[1]}_final"][dataset_name] += processor.column_accumulator(np.array(dEta_ij[:, pair[0]][sel_mask])) output[f"dR_{pair[0]}{pair[1]}_final"][dataset_name] += processor.column_accumulator(np.array(dR_ij[:, pair[0]][sel_mask])) output[f"moverM_01_final"][dataset_name] += processor.column_accumulator(np.array(m_01_overM[sel_mask])) output[f"moverM_12_final"][dataset_name] += processor.column_accumulator(np.array(m_12_overM[sel_mask])) output[f"moverM_20_final"][dataset_name] += processor.column_accumulator(np.array(m_20_overM[sel_mask])) for pair in [(0, 1, 2), (1, 2, 0), (2, 0, 1)]: output[f"dR_{pair[0]}_{pair[1]}{pair[2]}_final"][dataset_name] += processor.column_accumulator(np.array(dR_i_jk[:, pair[0]][sel_mask])) output[f"dEta_{pair[0]}_{pair[1]}{pair[2]}_final"][dataset_name] += processor.column_accumulator(np.array(dEta_i_jk[:, pair[0]][sel_mask])) output[f"Phi_{pair[0]}_{pair[1]}{pair[2]}_final"][dataset_name] += processor.column_accumulator(np.array(dPhi_i_jk[:, pair[0]][sel_mask])) output[f"dPtoverM_0_12_final"][dataset_name] += processor.column_accumulator(np.array(dPtoverM_0_12[sel_mask])) output[f"dPtoverM_1_20_final"][dataset_name] += processor.column_accumulator(np.array(dPtoverM_1_20[sel_mask])) output[f"dPtoverM_2_01_final"][dataset_name] += processor.column_accumulator(np.array(dPtoverM_2_01[sel_mask])) max_pt_overM_2fill = awk.max(pt_i_overM[sel_mask], axis=1) min_pt_overM_2fill = awk.min(pt_i_overM[sel_mask], axis=1) max_dR_2fill = awk.max(dR_ij[sel_mask], axis=1) max_dEta_2fill = awk.max(dEta_ij[sel_mask], axis=1) min_dR_2fill = awk.min(dR_ij[sel_mask], axis=1) min_dEta_2fill = awk.min(dEta_ij[sel_mask], axis=1) min_pt_2fill = awk.min(selected_jets[sel_mask].pt, axis=1) max_eta_2fill = awk.max(abs(selected_jets[sel_mask].eta), axis=1) max_dR_i_jk_2fill = awk.max(dR_i_jk[sel_mask], axis=1) min_dR_i_jk_2fill = awk.min(dR_i_jk[sel_mask], axis=1) max_dEta_i_jk_2fill = awk.max(dEta_i_jk[sel_mask], axis=1) min_dEta_i_jk_2fill = awk.min(dEta_i_jk[sel_mask], axis=1) max_dPhi_i_jk_2fill = awk.max(dPhi_i_jk[sel_mask], axis=1) min_dPhi_i_jk_2fill = awk.min(dPhi_i_jk[sel_mask], axis=1) max_dPtoverM_i_jk_2fill = [] min_dPtoverM_i_jk_2fill = [] dPtoverM_0_12_2fill = dPtoverM_0_12[sel_mask] dPtoverM_1_20_2fill = dPtoverM_1_20[sel_mask] dPtoverM_2_01_2fill = dPtoverM_2_01[sel_mask] for pair in zip(dPtoverM_0_12_2fill, dPtoverM_1_20_2fill, dPtoverM_2_01_2fill): max_dPtoverM_i_jk_2fill.append(max(pair)) min_dPtoverM_i_jk_2fill.append(min(pair)) max_pt_overM_2fill = awk.fill_none(max_pt_overM_2fill, -99) min_pt_overM_2fill = awk.fill_none(min_pt_overM_2fill, -99) max_dR_2fill = awk.fill_none(max_dR_2fill, -99) max_dEta_2fill = awk.fill_none(max_dEta_2fill, -99) min_dR_2fill = awk.fill_none(min_dR_2fill, -99) min_dEta_2fill = awk.fill_none(min_dEta_2fill, -99) min_pt_2fill = awk.fill_none(min_pt_2fill, -99) max_eta_2fill = awk.fill_none(max_eta_2fill, -99) max_dR_i_jk_2fill = awk.fill_none(max_dR_i_jk_2fill, -99) min_dR_i_jk_2fill = awk.fill_none(min_dR_i_jk_2fill, -99) max_dEta_i_jk_2fill = awk.fill_none(max_dEta_i_jk_2fill, -99) min_dEta_i_jk_2fill = awk.fill_none(min_dEta_i_jk_2fill, -99) max_dPhi_i_jk_2fill = awk.fill_none(max_dPhi_i_jk_2fill, -99) min_dPhi_i_jk_2fill = awk.fill_none(min_dPhi_i_jk_2fill, -99) output[f"ptoverM_max_final"][dataset_name] += processor.column_accumulator(np.array(max_pt_overM_2fill)) output[f"ptoverM_min_final"][dataset_name] += processor.column_accumulator(np.array(min_pt_overM_2fill)) output[f"eta_max_final"][dataset_name] += processor.column_accumulator(np.array(max_eta_2fill)) output[f"dR_max_final"][dataset_name] += processor.column_accumulator(np.array(max_dR_2fill)) output[f"dR_min_final"][dataset_name] += processor.column_accumulator(np.array(min_dR_2fill)) output[f"dEta_max_final"][dataset_name] += processor.column_accumulator(np.array(max_dEta_2fill)) output[f"dEta_min_final"][dataset_name] += processor.column_accumulator(np.array(min_dEta_2fill)) output[f"dR_j_jj_max_final"][dataset_name] += processor.column_accumulator(np.array(max_dR_i_jk_2fill)) output[f"dR_j_jj_min_final"][dataset_name] += processor.column_accumulator(np.array(min_dR_i_jk_2fill)) output[f"dEta_j_jj_max_final"][dataset_name] += processor.column_accumulator(np.array(max_dEta_i_jk_2fill)) output[f"dEta_j_jj_min_final"][dataset_name] += processor.column_accumulator(np.array(min_dEta_i_jk_2fill)) output[f"dPhi_j_jj_max_final"][dataset_name] += processor.column_accumulator(np.array(max_dPhi_i_jk_2fill)) output[f"dPhi_j_jj_min_final"][dataset_name] += processor.column_accumulator(np.array(min_dPhi_i_jk_2fill)) output[f"dPtoverM_j_jj_max_final"][dataset_name] += processor.column_accumulator(np.array(max_dPtoverM_i_jk_2fill)) output[f"dPtoverM_j_jj_min_final"][dataset_name] += processor.column_accumulator(np.array(min_dPtoverM_i_jk_2fill)) return output
def runOneFile(filename): #print ("filename: ", filename) #inputfile=filename outputfile = "output/" + inputfile.split("/")[-1] #outputfile = "tmp.root" mycache = uproot4.LRUArrayCache("1 MB") file_ = uproot4.open(inputfile, num_workers=10) #print ("root file opened: ", filename) nevents = ak.to_list(file_["h_total_mcweight"].values())[2] #nevents = 1000000 print("histogram opened: ", nevents) #tree_ = uproot4.open(inputfile, num_workers=10)["outTree"].arrays(array_cache=mycache) tree_ = file_["outTree"].arrays(array_cache=mycache) print("tree length", len(tree_)) #tree_ = uproot4.open(inputfile)[trees[0]].arrays() #tree_ = uproot4.open(inputfile)["outTree"].arrays(array_cache=mycache) #tree_ = uproot4.open("Merged_WJetsInclusiveSkim.root")["outTree"].arrays(array_cache=mycache) #tree_ = uproot4.open("/eos/cms/store/group/phys_exotica/bbMET/2016_SkimmedFiles/skim_setup_2016_v16_07-00/crab_DYJetsToLL_M-50_HT-400to600_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_200918_215129_0000_0.root")["outTree"].arrays(array_cache=mycache) #tree_ = uproot4.open("/eos/cms/store/group/phys_exotica/bbMET/2016_SkimmedFiles/skim_setup_2016_v16_07-00/crab_ttHTobb_M125_13TeV_powheg_pythia8_200918_215950_0000_0.root")["outTree"].arrays(array_cache=mycache) #print ((tree_)) cms_events = ak.zip( { "run": tree_["st_runId"], "lumi": tree_["st_lumiSection"], "event": tree_["st_eventId"], "jetpx": tree_["st_THINjetPx"], "jetpy": tree_["st_THINjetPy"], "jetpz": tree_["st_THINjetPz"], "jete": tree_["st_THINjetEnergy"], "jetpt": getpt(tree_["st_THINjetPx"], tree_["st_THINjetPy"]), "jeteta": geteta(tree_["st_THINjetPx"], tree_["st_THINjetPy"], tree_["st_THINjetPz"]), "jetphi": getphi(tree_["st_THINjetPx"], tree_["st_THINjetPy"]), "jetcsv": tree_["st_THINjetDeepCSV"], "jetflav": tree_["st_THINjetHadronFlavor"], "metpt": tree_["st_pfMetCorrPt"], "metphi": tree_["st_pfMetCorrPhi"], "mettrig": tree_["st_mettrigdecision"], "elepx": tree_["st_elePx"], "elepy": tree_["st_elePy"], "elepz": tree_["st_elePz"], "elee": tree_["st_eleEnergy"], "eleidL": tree_["st_eleIsPassLoose"], "eleidT": tree_["st_eleIsPassTight"], "eleq": tree_["st_eleCharge"], "elept": getpt(tree_["st_elePx"], tree_["st_elePy"]), "eleeta": geteta(tree_["st_elePx"], tree_["st_elePy"], tree_["st_elePz"]), "elephi": getphi(tree_["st_elePx"], tree_["st_elePy"]), "mupx": tree_["st_muPx"], "mupy": tree_["st_muPy"], "mupz": tree_["st_muPz"], "mue": tree_["st_muEnergy"], "muidT": tree_["st_isTightMuon"], "muq": tree_["st_muCharge"], "mupt": getpt(tree_["st_muPx"], tree_["st_muPy"]), "mueta": geteta(tree_["st_muPx"], tree_["st_muPy"], tree_["st_muPz"]), "muphi": getphi(tree_["st_muPx"], tree_["st_muPy"]), "ntau": tree_["st_nTau_discBased_TightEleTightMuVeto"], "npho": tree_["st_nPho"], "phopx": tree_["st_phoPx"], "phopy": tree_["st_phoPy"], "phopz": tree_["st_phoPz"], "phoe": tree_["st_phoEnergy"], "phopt": getpt(tree_["st_phoPx"], tree_["st_phoPy"]), "phoeta": geteta(tree_["st_phoPx"], tree_["st_phoPy"], tree_["st_phoPz"]), "nTrueInt": tree_["st_pu_nTrueInt"], "nPUVert": tree_["st_pu_nPUVert"], "genpt": tree_["st_genParPt"] }, depth_limit=1) out_events = ak.zip( { "run": tree_["st_runId"], "lumi": tree_["st_lumiSection"], "event": tree_["st_eventId"] }, depth_limit=1) print("event loading done") print("# of events: ", len(cms_events)) ## add more columns/properties to the event cms_events["mu_sel_tight"] = (cms_events.mupt > 30) & ( cms_events.muidT == True) & (numpy.abs(cms_events.mueta) < 2.4) cms_events["mu_sel_tight0"] = ak.Array(getN(cms_events.mu_sel_tight, 0)) cms_events["nMuTight"] = ak.sum(cms_events.mu_sel_tight, axis=-1) cms_events["nMuLoose"] = ak.sum((cms_events.mupt > 10), axis=-1) cms_events["mu_q0"] = ak.Array(getN(cms_events.muq, 0)) cms_events["mu_q1"] = ak.Array(getN(cms_events.muq, 1)) cms_events["ele_sel_tight"] = (cms_events.eleidT == True) & ( cms_events.elept > 30) & (numpy.abs(cms_events.eleeta) < 2.5) cms_events["ele_sel_tight0"] = ak.Array(getN(cms_events.ele_sel_tight, 0)) cms_events["nEleTight"] = ak.sum(cms_events.ele_sel_tight, axis=-1) cms_events["nEleLoose"] = ak.sum((cms_events.elept > 10), axis=-1) cms_events["ele_q0"] = ak.Array(getN(cms_events.eleq, 0)) cms_events["ele_q1"] = ak.Array(getN(cms_events.eleq, 1)) cms_events["recoil_Wmunu"] = getrecoil(cms_events.nMuTight, cms_events.mupt, cms_events.muphi, cms_events.mupx, cms_events.mupy, cms_events.metpt, cms_events.metphi) cms_events["recoil_Wmunu0"] = ak.firsts(cms_events.recoil_Wmunu) cms_events["recoil_Wenu"] = getrecoil(cms_events.nEleTight, cms_events.elept, cms_events.elephi, cms_events.elepx, cms_events.elepy, cms_events.metpt, cms_events.metphi) cms_events["recoil_Wenu0"] = ak.firsts(cms_events.recoil_Wenu) elepx0 = ak.Array(getN(cms_events.elepx, 0)) elepx1 = ak.Array(getN(cms_events.elepx, 1)) elepy0 = ak.Array(getN(cms_events.elepy, 0)) elepy1 = ak.Array(getN(cms_events.elepy, 1)) elepz0 = ak.Array(getN(cms_events.elepz, 0)) elepz1 = ak.Array(getN(cms_events.elepz, 1)) elee0 = ak.Array(getN(cms_events.elee, 0)) elee1 = ak.Array(getN(cms_events.elee, 1)) cms_events["Zee_mass"] = numpy.sqrt((elee0 + elee1)**2 - (elepx0 + elepx1)**2 - (elepy0 + elepy1)**2 - (elepz0 + elepz1)**2) cms_events["Zee_pt"] = numpy.sqrt((elepx0 + elepx1)**2 + (elepy0 + elepy1)**2) cms_events["Zee_recoil"] = getrecoil1((elepx0 + elepx1), (elepy0 + elepy1), cms_events.metpt, cms_events.metphi) mupx0 = ak.Array(getN(cms_events.mupx, 0)) mupx1 = ak.Array(getN(cms_events.mupx, 1)) mupy0 = ak.Array(getN(cms_events.mupy, 0)) mupy1 = ak.Array(getN(cms_events.mupy, 1)) mupz0 = ak.Array(getN(cms_events.mupz, 0)) mupz1 = ak.Array(getN(cms_events.mupz, 1)) mue0 = ak.Array(getN(cms_events.mue, 0)) mue1 = ak.Array(getN(cms_events.mue, 1)) cms_events["Zmumu_mass"] = numpy.sqrt((mue0 + mue1)**2 - (mupx0 + mupx1)**2 - (mupy0 + mupy1)**2 - (mupz0 + mupz1)**2) cms_events["Zmumu_pt"] = numpy.sqrt((mupx0 + mupx1)**2 + (mupy0 + mupy1)**2) cms_events["Zmumu_recoil"] = getrecoil1( (mupx0 + mupx1), (mupy0 + mupy1), cms_events.metpt, cms_events.metphi) #cms_events["recoil_Zmumu"] = getrecoil cms_events["recoil_WmunuPhi"] = getRecoilPhi( cms_events.nMuTight, cms_events.mupt, cms_events.muphi, cms_events.mupx, cms_events.mupy, cms_events.metpt, cms_events.metphi) cms_events["recoil_WmunuPhi0"] = ak.firsts(cms_events.recoil_WmunuPhi) cms_events["recoil_WenuPhi"] = getRecoilPhi( cms_events.nEleTight, cms_events.elept, cms_events.elephi, cms_events.elepx, cms_events.elepy, cms_events.metpt, cms_events.metphi) cms_events["recoil_WenuPhi0"] = ak.firsts(cms_events.recoil_WenuPhi) cms_events["mt_Wmunu"] = getMT(cms_events.nMuTight, cms_events.mupt, cms_events.muphi, cms_events.mupx, cms_events.mupy, cms_events.metpt, cms_events.metphi) cms_events["mt_Wmunu0"] = ak.firsts(cms_events.mt_Wmunu) cms_events["mt_Wenu"] = getMT(cms_events.nEleTight, cms_events.elept, cms_events.elephi, cms_events.elepx, cms_events.elepy, cms_events.metpt, cms_events.metphi) cms_events["mt_Wenu0"] = ak.firsts(cms_events.mt_Wenu) cms_events["jet_sel_loose"] = (cms_events.jetpt > 30.0) & (numpy.abs( cms_events.jeteta) < 2.5) cms_events["jet_sel_tight"] = (cms_events.jetpt > 50.0) & (numpy.abs( cms_events.jeteta) < 2.5) #cms_events["jet_sel_b"] = (cms_events.jetcsv > 0.6321) & (numpy.abs(cms_events.jeteta)<2.4) cms_events["jet_sel_b"] = ( cms_events.jetcsv[cms_events.jet_sel_loose == True] > 0.6321 ) & (numpy.abs(cms_events.jeteta[cms_events.jet_sel_loose == True]) < 2.4) cms_events["jetptTight"] = cms_events.jetpt[cms_events.jet_sel_tight == True] cms_events["jetetaTight"] = cms_events.jeteta[cms_events.jet_sel_tight == True] cms_events["jetphiTight"] = cms_events.jetphi[cms_events.jet_sel_tight == True] cms_events["jetptLoose"] = cms_events.jetpt[cms_events.jet_sel_loose == True] cms_events["jetetaLoose"] = cms_events.jeteta[cms_events.jet_sel_loose == True] cms_events["jetphiLoose"] = cms_events.jetphi[cms_events.jet_sel_loose == True] cms_events["jet_sel_tight0"] = ak.Array( getN(cms_events.jet_sel_tight[cms_events.jet_sel_loose == True], 0)) cms_events["jet_sel_b_0"] = ak.Array(getN(cms_events.jet_sel_b, 0)) cms_events["jet_sel_b_1"] = ak.Array(getN(cms_events.jet_sel_b, 1)) cms_events["nJetLoose"] = ak.sum(cms_events.jet_sel_loose, axis=-1) cms_events["nJetTight"] = ak.sum(cms_events.jet_sel_tight, axis=-1) cms_events["nJetb"] = ak.sum(cms_events.jet_sel_b, axis=-1) cms_events["dphi_jet_met"] = DeltaPhi( cms_events.jetphi[cms_events.jet_sel_loose == True], cms_events.metphi) cms_events["min_dphi_jet_met"] = ak.min(cms_events.dphi_jet_met, axis=-1) #-------------------------------------------------------------------------------------------------- ## W --> lepton + nu #-------------------------------------------------------------------------------------------------- from regions import get_mask_wmunu1b, get_mask_wmunu2b, get_mask_wenu1b, get_mask_wenu2b, get_mask_topmunu1b, get_mask_topmunu2b, get_mask_topenu1b, get_mask_topenu2b, get_mask_Zmumu1b, get_mask_Zmumu2b, get_mask_Zee1b, get_mask_Zee2b, get_mask_SR1b, get_mask_SR2b cms_events["mask_wmunu1b"] = get_mask_wmunu1b(cms_events) cms_events["mask_wmunu2b"] = get_mask_wmunu2b(cms_events) cms_events["mask_wenu1b"] = get_mask_wenu1b(cms_events) cms_events["mask_wenu2b"] = get_mask_wenu2b(cms_events) cms_events["mask_topmunu1b"] = get_mask_topmunu1b(cms_events) cms_events["mask_topmunu2b"] = get_mask_topmunu2b(cms_events) cms_events["mask_topenu1b"] = get_mask_topenu1b(cms_events) cms_events["mask_topenu2b"] = get_mask_topenu2b(cms_events) cms_events["mask_Zmumu1b"] = get_mask_Zmumu1b(cms_events) cms_events["mask_Zmumu2b"] = get_mask_Zmumu2b(cms_events) cms_events["mask_Zee1b"] = get_mask_Zee1b(cms_events) cms_events["mask_Zee2b"] = get_mask_Zee2b(cms_events) cms_events["mask_SR1b"] = get_mask_SR1b(cms_events) cms_events["mask_SR2b"] = get_mask_SR2b(cms_events) ''' wm = cms_events.event[mask_SR2b] wm[~ak.is_none(wm)] ''' ############### out_events["metpt"] = cms_events["metpt"] out_events["metphi"] = cms_events["metphi"] out_events["nTrueInt"] = cms_events["nTrueInt"] out_events["nJetLoose"] = cms_events["nJetLoose"] out_events["mu_sel_tight0"] = cms_events["mu_sel_tight0"] out_events["nMuTight"] = cms_events["nMuTight"] out_events["nMuLoose"] = cms_events["nMuLoose"] out_events["mu_q0"] = cms_events["mu_q0"] out_events["mu_q1"] = cms_events["mu_q1"] out_events["mupt0"] = ak.Array(getN(cms_events.mupt, 0)) out_events["mupt1"] = ak.Array(getN(cms_events.mupt, 1)) out_events["mueta0"] = ak.Array(getN(cms_events.mueta, 0)) out_events["mueta1"] = ak.Array(getN(cms_events.mueta, 1)) out_events["muphi0"] = ak.Array(getN(cms_events.muphi, 0)) out_events["muphi1"] = ak.Array(getN(cms_events.muphi, 1)) out_events["ele_sel_tight0"] = cms_events["ele_sel_tight0"] out_events["nEleTight"] = cms_events["nEleTight"] out_events["nEleLoose"] = cms_events["nEleLoose"] out_events["ele_q0"] = cms_events["ele_q0"] out_events["ele_q1"] = cms_events["ele_q1"] out_events["elept0"] = ak.Array(getN(cms_events.elept, 0)) out_events["elept1"] = ak.Array(getN(cms_events.elept, 1)) out_events["eleeta0"] = ak.Array(getN(cms_events.eleeta, 0)) out_events["eleeta1"] = ak.Array(getN(cms_events.eleeta, 1)) out_events["elephi0"] = ak.Array(getN(cms_events.elephi, 0)) out_events["elephi1"] = ak.Array(getN(cms_events.elephi, 1)) out_events["recoil_Wmunu0"] = cms_events["recoil_Wmunu0"] out_events["recoil_Wenu0"] = cms_events["recoil_Wenu0"] out_events["recoil_WmunuPhi0"] = cms_events["recoil_WmunuPhi0"] out_events["recoil_WenuPhi0"] = cms_events["recoil_WenuPhi0"] out_events["mt_Wmunu0"] = cms_events["mt_Wmunu0"] out_events["mt_Wenu0"] = cms_events["mt_Wenu0"] out_events["Zee_mass"] = cms_events["Zee_mass"] out_events["Zee_pt"] = cms_events["Zee_pt"] out_events["Zee_recoil"] = cms_events["Zee_recoil"] out_events["Zmumu_mass"] = cms_events["Zmumu_mass"] out_events["Zmumu_pt"] = cms_events["Zmumu_pt"] out_events["Zmumu_recoil"] = cms_events["Zmumu_recoil"] out_events["nJetLoose"] = cms_events["nJetLoose"] out_events["nJetTight"] = cms_events["nJetTight"] out_events["nJetb"] = cms_events["nJetb"] out_events["min_dphi_jet_met"] = cms_events["min_dphi_jet_met"] cms_events["jet_sel_tight0"] = cms_events["jet_sel_tight0"] cms_events["jet_sel_b_0"] = cms_events["jet_sel_b_0"] cms_events["jet_sel_b_1"] = cms_events["jet_sel_b_1"] out_events["jetpt0"] = ak.Array(getN(cms_events.jetptTight, 0)) out_events["jetpt1"] = ak.Array(getN(cms_events.jetptLoose, 1)) out_events["jetpt2"] = ak.Array(getN(cms_events.jetptLoose, 2)) out_events["jetpt3"] = ak.Array(getN(cms_events.jetptLoose, 3)) out_events["jetpt4"] = ak.Array(getN(cms_events.jetptLoose, 4)) out_events["jetpt5"] = ak.Array(getN(cms_events.jetptLoose, 5)) out_events["jetpt6"] = ak.Array(getN(cms_events.jetptLoose, 6)) out_events["jeteta0"] = ak.Array(getN(cms_events.jetetaTight, 0)) out_events["jeteta1"] = ak.Array(getN(cms_events.jetetaLoose, 1)) out_events["jeteta2"] = ak.Array(getN(cms_events.jetetaLoose, 2)) out_events["jeteta3"] = ak.Array(getN(cms_events.jetetaLoose, 3)) out_events["jeteta4"] = ak.Array(getN(cms_events.jetetaLoose, 4)) out_events["jeteta5"] = ak.Array(getN(cms_events.jetetaLoose, 5)) out_events["jeteta6"] = ak.Array(getN(cms_events.jetetaLoose, 6)) out_events["jetphi0"] = ak.Array(getN(cms_events.jetphiTight, 0)) out_events["jetphi1"] = ak.Array(getN(cms_events.jetphiLoose, 1)) out_events["jetphi2"] = ak.Array(getN(cms_events.jetphiLoose, 2)) out_events["jetflav0"] = ak.Array( getN(cms_events.jetflav[cms_events.jet_sel_tight == True], 0)) out_events["jetflav1"] = ak.Array( getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 1)) out_events["jetflav2"] = ak.Array( getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 2)) out_events["jetflav3"] = ak.Array( getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 3)) out_events["jetflav4"] = ak.Array( getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 4)) out_events["jetflav5"] = ak.Array( getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 5)) out_events["jetflav6"] = ak.Array( getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 6)) out_events["csv0"] = ak.Array( getN(cms_events.jetcsv[cms_events.jet_sel_tight == True], 0)) out_events["csv1"] = ak.Array( getN(cms_events.jetcsv[cms_events.jet_sel_loose == True], 1)) out_events["csv2"] = ak.Array( getN(cms_events.jetcsv[cms_events.jet_sel_loose == True], 2)) out_events["csv3"] = ak.Array( getN(cms_events.jetcsv[cms_events.jet_sel_loose == True], 3)) out_events["SR_2b"] = cms_events["mask_SR2b"] out_events["SR_1b"] = cms_events["mask_SR1b"] out_events["ZeeCR_2b"] = cms_events["mask_Zee2b"] out_events["ZeeCR_1b"] = cms_events["mask_Zee1b"] out_events["ZmumuCR_2b"] = cms_events["mask_Zmumu2b"] out_events["ZmumuCR_1b"] = cms_events["mask_Zmumu1b"] out_events["TopenuCR_2b"] = cms_events["mask_topenu2b"] out_events["TopenuCR_1b"] = cms_events["mask_topenu1b"] out_events["TopmunuCR_2b"] = cms_events["mask_topmunu2b"] out_events["TopmunuCR_1b"] = cms_events["mask_topmunu1b"] out_events["WenuCR_1b"] = cms_events["mask_wenu1b"] out_events["WenuCR_2b"] = cms_events["mask_wenu2b"] out_events["WmunuCR_1b"] = cms_events["mask_wmunu1b"] out_events["WmunuCR_2b"] = cms_events["mask_wmunu2b"] ## btagging SFs from read_sfs import btag_sf from read_sfs import evaluator out_events["btagsf0"] = btag_sf.eval("central", out_events.jetflav0, abs(out_events.jeteta0), out_events.jetpt0) out_events["btagsf1"] = btag_sf.eval("central", out_events.jetflav1, abs(out_events.jeteta1), out_events.jetpt1) out_events["btagsf2"] = btag_sf.eval("central", out_events.jetflav2, abs(out_events.jeteta2), out_events.jetpt2) out_events["btagsf3"] = btag_sf.eval("central", out_events.jetflav3, abs(out_events.jeteta3), out_events.jetpt3) out_events["btagsf4"] = btag_sf.eval("central", out_events.jetflav4, abs(out_events.jeteta4), out_events.jetpt4) out_events["btagsf5"] = btag_sf.eval("central", out_events.jetflav5, abs(out_events.jeteta5), out_events.jetpt5) out_events["btagsf6"] = btag_sf.eval("central", out_events.jetflav6, abs(out_events.jeteta6), out_events.jetpt6) ## btag efficiency out_events["btag_eff_lwp_0"] = evaluator["btag_eff_lwp"]( out_events.jeteta0, out_events.jetpt0) out_events["btag_eff_lwp_1"] = evaluator["btag_eff_lwp"]( out_events.jeteta1, out_events.jetpt1) out_events["ctag_eff_lwp_0"] = evaluator["ctag_eff_lwp"]( out_events.jeteta0, out_events.jetpt0) out_events["ctag_eff_lwp_1"] = evaluator["ctag_eff_lwp"]( out_events.jeteta1, out_events.jetpt1) out_events["ltag_eff_lwp_0"] = evaluator["ltag_eff_lwp"]( out_events.jeteta0, out_events.jetpt0) out_events["ltag_eff_lwp_1"] = evaluator["ltag_eff_lwp"]( out_events.jeteta1, out_events.jetpt1) out_events["btag_eff_mwp_0"] = evaluator["btag_eff_mwp"]( out_events.jeteta0, out_events.jetpt0) out_events["btag_eff_mwp_1"] = evaluator["btag_eff_mwp"]( out_events.jeteta1, out_events.jetpt1) out_events["ctag_eff_mwp_0"] = evaluator["ctag_eff_mwp"]( out_events.jeteta0, out_events.jetpt0) out_events["ctag_eff_mwp_1"] = evaluator["ctag_eff_mwp"]( out_events.jeteta1, out_events.jetpt1) out_events["ltag_eff_mwp_0"] = evaluator["ltag_eff_mwp"]( out_events.jeteta0, out_events.jetpt0) out_events["ltag_eff_mwp_1"] = evaluator["ltag_eff_mwp"]( out_events.jeteta1, out_events.jetpt1) ## ele sfs out_events["eleTightSF0"] = evaluator["EGamma_SF2D_T"](out_events.eleeta0, out_events.elept0) out_events["eleLooseSF1"] = evaluator["EGamma_SF2D_L"](out_events.eleeta1, out_events.elept1) out_events["eleTrigSF0"] = evaluator["EGamma_SF2D_Trig"]( out_events.eleeta0, out_events.elept0) out_events["eleRecoSF0"] = evaluator["EGamma_SF2D_Reco"]( out_events.eleeta0, out_events.elept0) eleRecoSF1_hi = evaluator["EGamma_SF2D_Reco"](out_events.eleeta1, out_events.elept1) eleRecoSF1_lo = evaluator["EGamma_SF2D_Reco_lowpt"](out_events.eleeta1, out_events.elept1) eleRecoSF1_hi_ = ak.fill_none( ak.mask(eleRecoSF1_hi, out_events.elept1 > 20.), 0) eleRecoSF1_lo_ = ak.fill_none( ak.mask(eleRecoSF1_lo, out_events.elept1 > 20.), 0) out_events["eleRecoSF1"] = eleRecoSF1_hi_ + eleRecoSF1_lo_ ## muon sfs bcdef_lumi = 19.554725529 gh_lumi = 16.224846377 total_lumi = bcdef_lumi + gh_lumi ##--------low pt Loose muonLooseIDSF_lowpt1 = ( (bcdef_lumi * evaluator["muon_lowpt_BCDEF_LooseID"] (out_events.mupt1, abs(out_events.mueta1))) + (gh_lumi * evaluator["muon_lowpt_GH_LooseID"] (out_events.mupt1, abs(out_events.mueta1)))) / total_lumi ##----------- medium pt Loose muonLooseIDSF1 = ((bcdef_lumi * evaluator["muon_highpt_BCDEF_LooseID"] (out_events.mueta1, out_events.mupt1)) + (gh_lumi * evaluator["muon_highpt_GH_LooseID"] (out_events.mueta1, out_events.mupt1))) / total_lumi muonLooseISOSF1 = ((bcdef_lumi * evaluator["muon_highpt_BCDEF_LooseISO"] (out_events.mueta1, out_events.mupt1)) + (gh_lumi * evaluator["muon_highpt_GH_LooseISO"] (out_events.mueta1, out_events.mupt1))) / total_lumi muon_loose_ID_low_SF_1 = ak.fill_none( ak.mask(muonLooseIDSF_lowpt1, out_events.mupt1 < 20.), 0) muon_loose_ID_high_SF_1 = ak.fill_none( ak.mask(muonLooseIDSF1, out_events.mupt1 > 20.), 0) muon_loose_ID_SF_1 = muon_loose_ID_low_SF_1 + muon_loose_ID_high_SF_1 out_events["muLooseSF1"] = muon_loose_ID_SF_1 * muonLooseISOSF1 ##------------medium pt tight muonTightIDSF0 = ((bcdef_lumi * evaluator["muon_highpt_BCDEF_TightID"] (out_events.mueta0, out_events.mupt0)) + (gh_lumi * evaluator["muon_highpt_GH_TightID"] (out_events.mueta0, out_events.mupt0))) / total_lumi muonTightISOSF0 = ((bcdef_lumi * evaluator["muon_highpt_BCDEF_TightISO"] (out_events.mueta0, out_events.mupt0)) + (gh_lumi * evaluator["muon_highpt_GH_TightISO"] (out_events.mueta0, out_events.mupt0))) / total_lumi out_events["muTightSF0"] = muonTightIDSF0 * muonTightISOSF0 out_events["puweight"] = evaluator["pu_weight"](cms_events.nTrueInt) ## trigger sfs out_events["mettrigWeight"] = evaluator["met_trig"](cms_events.metpt) out_events["recoilWmunutrigWeight"] = evaluator["met_trig"]( cms_events.recoil_Wmunu0) out_events["recoilWenutrigWeight"] = evaluator["met_trig"]( cms_events.recoil_Wenu0) out_events["recoilZmumutrigWeight"] = evaluator["met_trig"]( cms_events.Zmumu_recoil) out_events["recoilZeetrigWeight"] = evaluator["met_trig"]( cms_events.Zee_recoil) ## Fill weights for each CR so that we don't need to worry later out_events["weight_SR_2b"] = out_events.puweight * out_events.mettrigWeight out_events["weight_SR_1b"] = out_events.puweight * out_events.mettrigWeight out_events["weight_ZeeCR_2b"] = out_events.puweight * out_events.eleTrigSF0 out_events["weight_ZeeCR_1b"] = out_events.puweight * out_events.eleTrigSF0 out_events[ "weight_ZmumuCR_2b"] = out_events.puweight * out_events.recoilZmumutrigWeight out_events[ "weight_ZmumuCR_1b"] = out_events.puweight * out_events.recoilZmumutrigWeight out_events[ "weight_TopenuCR_2b"] = out_events.puweight * out_events.eleTrigSF0 out_events[ "weight_TopenuCR_1b"] = out_events.puweight * out_events.eleTrigSF0 out_events[ "weight_TopmunuCR_2b"] = out_events.puweight * out_events.recoilWmunutrigWeight out_events[ "weight_TopmunuCR_1b"] = out_events.puweight * out_events.recoilWmunutrigWeight out_events[ "weight_WenuCR_1b"] = out_events.puweight * out_events.eleTrigSF0 out_events[ "weight_WenuCR_2b"] = out_events.puweight * out_events.eleTrigSF0 out_events[ "weight_WmunuCR_1b"] = out_events.puweight * out_events.recoilWmunutrigWeight out_events[ "weight_WmunuCR_2b"] = out_events.puweight * out_events.recoilWmunutrigWeight ## Fill Histograms from variables import vardict, regions, variables_common from binning import binning f = TFile(outputfile, "RECREATE") for ireg in regions: thisregion = out_events[out_events[ireg] == True] thisregion_ = thisregion[~(ak.is_none(thisregion))] weight_ = "weight_" + ireg for ivar in variables_common[ireg]: hist_name_ = "h_reg_" + ireg + "_" + vardict[ivar] h = VarToHist(thisregion_[ivar], thisregion_[weight_], hist_name_, binning[ireg][ivar]) f.cd() h.Write() h_total = TH1F("h_total_mcweight", "h_total_mcweight", 2, 0, 2) h_total.SetBinContent(1, nevents) f.cd() h_total.Write() write_parquet = False if write_parquet: ak.to_parquet(out_events, "analysis_wjets_allevents.parquet")
def process(self, events): output = self.accumulator.identity() # use a very loose preselection to filter the events presel = ak.num(events.Jet)>2 ev = events[presel] dataset = ev.metadata['dataset'] # load the config - probably not needed anymore cfg = loadConfig() output['totalEvents']['all'] += len(events) output['skimmedEvents']['all'] += len(ev) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): ## Generated leptons gen_lep = ev.GenL leading_gen_lep = gen_lep[ak.singletons(ak.argmax(gen_lep.pt, axis=1))] trailing_gen_lep = gen_lep[ak.singletons(ak.argmin(gen_lep.pt, axis=1))] # Get the leptons. This has changed a couple of times now, but we are using fakeable objects as baseline leptons. # The added p4 instance has the corrected pt (conePt for fakeable) and should be used for any following selection or calculation # Any additional correction (if we choose to do so) should be added here, e.g. Rochester corrections, ... ## Muons mu_v = Collections(ev, "Muon", "vetoTTH", year=year).get() # these include all muons, tight and fakeable mu_t = Collections(ev, "Muon", "tightSSTTH", year=year).get() mu_f = Collections(ev, "Muon", "fakeableSSTTH", year=year).get() muon = ak.concatenate([mu_t, mu_f], axis=1) muon['p4'] = get_four_vec_fromPtEtaPhiM(muon, get_pt(muon), muon.eta, muon.phi, muon.mass, copy=False) #FIXME new ## Electrons el_v = Collections(ev, "Electron", "vetoTTH", year=year).get() el_t = Collections(ev, "Electron", "tightSSTTH", year=year).get() el_f = Collections(ev, "Electron", "fakeableSSTTH", year=year).get() electron = ak.concatenate([el_t, el_f], axis=1) electron['p4'] = get_four_vec_fromPtEtaPhiM(electron, get_pt(electron), electron.eta, electron.phi, electron.mass, copy=False) #FIXME new if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): el_t_p = prompt(el_t) el_t_np = nonprompt(el_t) el_f_p = prompt(el_f) el_f_np = nonprompt(el_f) mu_t_p = prompt(mu_t) mu_t_np = nonprompt(mu_t) mu_f_p = prompt(mu_f) mu_f_np = nonprompt(mu_f) is_flipped = ( (el_t_p.matched_gen.pdgId*(-1) == el_t_p.pdgId) & (abs(el_t_p.pdgId) == 11) ) el_t_p_cc = el_t_p[~is_flipped] # this is tight, prompt, and charge consistent el_t_p_cf = el_t_p[is_flipped] # this is tight, prompt, and charge flipped ## Merge electrons and muons. These are fakeable leptons now lepton = ak.concatenate([muon, electron], axis=1) leading_lepton_idx = ak.singletons(ak.argmax(lepton.p4.pt, axis=1)) leading_lepton = lepton[leading_lepton_idx] trailing_lepton_idx = ak.singletons(ak.argmin(lepton.p4.pt, axis=1)) trailing_lepton = lepton[trailing_lepton_idx] dilepton_mass = (leading_lepton.p4 + trailing_lepton.p4).mass dilepton_pt = (leading_lepton.p4 + trailing_lepton.p4).pt #dilepton_dR = delta_r(leading_lepton, trailing_lepton) dilepton_dR = leading_lepton.p4.delta_r(trailing_lepton.p4) lepton_pdgId_pt_ordered = ak.fill_none(ak.pad_none(lepton[ak.argsort(lepton.p4.pt, ascending=False)].pdgId, 2, clip=True), 0) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): n_nonprompt = getNonPromptFromFlavour(electron) + getNonPromptFromFlavour(muon) n_chargeflip = getChargeFlips(electron, ev.GenPart) + getChargeFlips(muon, ev.GenPart) gp = ev.GenPart gp_e = gp[((abs(gp.pdgId)==11)&(gp.status==1)&((gp.statusFlags&(1<<0))==1)&(gp.statusFlags&(1<<8)==256))] gp_m = gp[((abs(gp.pdgId)==13)&(gp.status==1)&((gp.statusFlags&(1<<0))==1)&(gp.statusFlags&(1<<8)==256))] n_gen_lep = ak.num(gp_e) + ak.num(gp_m) else: n_gen_lep = np.zeros(len(ev)) LL = (n_gen_lep > 2) # this is the classifier for LL events (should mainly be ttZ/tZ/WZ...) mt_lep_met = mt(lepton.p4.pt, lepton.p4.phi, ev.MET.pt, ev.MET.phi) min_mt_lep_met = ak.min(mt_lep_met, axis=1) ## Tau and other stuff tau = getTaus(ev) tau = tau[~match(tau, muon, deltaRCut=0.4)] tau = tau[~match(tau, electron, deltaRCut=0.4)] track = getIsoTracks(ev) ## Jets jet = getJets(ev, minPt=25, maxEta=4.7, pt_var='pt_nom') jet = jet[ak.argsort(jet.pt_nom, ascending=False)] # need to sort wrt smeared and recorrected jet pt jet = jet[~match(jet, muon, deltaRCut=0.4)] # remove jets that overlap with muons jet = jet[~match(jet, electron, deltaRCut=0.4)] # remove jets that overlap with electrons central = jet[(abs(jet.eta)<2.4)] btag = getBTagsDeepFlavB(jet, year=self.year) # should study working point for DeepJet light = getBTagsDeepFlavB(jet, year=self.year, invert=True) fwd = getFwdJet(light) fwd_noPU = getFwdJet(light, puId=False) high_score_btag = central[ak.argsort(central.btagDeepFlavB)][:,:2] bl = cross(lepton, high_score_btag) bl_dR = delta_r(bl['0'], bl['1']) min_bl_dR = ak.min(bl_dR, axis=1) ## forward jets j_fwd = fwd[ak.singletons(ak.argmax(fwd.p, axis=1))] # highest momentum spectator # try to get either the most forward light jet, or if there's more than one with eta>1.7, the highest pt one most_fwd = light[ak.argsort(abs(light.eta))][:,0:1] #most_fwd = light[ak.singletons(ak.argmax(abs(light.eta)))] best_fwd = ak.concatenate([j_fwd, most_fwd], axis=1)[:,0:1] jf = cross(j_fwd, jet) mjf = (jf['0']+jf['1']).mass j_fwd2 = jf[ak.singletons(ak.argmax(mjf, axis=1))]['1'] # this is the jet that forms the largest invariant mass with j_fwd delta_eta = abs(j_fwd2.eta - j_fwd.eta) ## MET -> can switch to puppi MET met_pt = ev.MET.pt met_phi = ev.MET.phi ## other variables ht = ak.sum(jet.pt, axis=1) #st = met_pt + ht + ak.sum(get_pt(muon), axis=1) + ak.sum(get_pt(electron), axis=1) st = met_pt + ht + ak.sum(lepton.p4.pt, axis=1) # define the weight weight = Weights( len(ev) ) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): # lumi weight weight.add("weight", ev.weight*cfg['lumi'][self.year]) # PU weight weight.add("PU", ev.puWeight, weightUp=ev.puWeightUp, weightDown=ev.puWeightDown, shift=False) # b-tag SFs weight.add("btag", self.btagSF.Method1a(btag, light)) # lepton SFs weight.add("lepton", self.leptonSF.get(electron, muon)) cutflow = Cutflow(output, ev, weight=weight) # slightly restructured # calculate everything from loose, require two tights on top # since n_tight == n_loose == 2, the tight and loose leptons are the same in the end # in this selection we'll get events with exactly two fakeable+tight and two loose leptons. sel = Selection( dataset = dataset, events = ev, year = self.year, ele = electron, ele_veto = el_v, mu = muon, mu_veto = mu_v, jet_all = jet, jet_central = central, jet_btag = btag, jet_fwd = fwd, jet_light = light, met = ev.MET, ) baseline = sel.dilep_baseline(cutflow=cutflow, SS=True, omit=['N_fwd>0']) baseline_OS = sel.dilep_baseline(cutflow=cutflow, SS=False, omit=['N_fwd>0']) # this is for charge flip estimation if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): BL = (baseline & ((ak.num(el_t_p_cc)+ak.num(mu_t_p))==2)) # this is the MC baseline for events with two tight prompt leptons BL_incl = (baseline & ((ak.num(el_t)+ak.num(mu_t))==2)) # this is the MC baseline for events with two tight leptons np_est_sel_mc = (baseline & \ ((((ak.num(el_t_p_cc)+ak.num(mu_t_p))==1) & ((ak.num(el_f_np)+ak.num(mu_f_np))==1)) | (((ak.num(el_t_p_cc)+ak.num(mu_t_p))==0) & ((ak.num(el_f_np)+ak.num(mu_f_np))==2)) )) # no overlap between tight and nonprompt, and veto on additional leptons. this should be enough np_obs_sel_mc = (baseline & ((ak.num(el_t)+ak.num(mu_t))==2) & ((ak.num(el_t_np)+ak.num(mu_t_np))>=1) ) # two tight leptons, at least one nonprompt np_est_sel_data = (baseline & ~baseline) # this has to be false cf_est_sel_mc = (baseline_OS & ((ak.num(el_t_p)+ak.num(mu_t_p))==2)) cf_obs_sel_mc = (baseline & ((ak.num(el_t)+ak.num(mu_t))==2) & ((ak.num(el_t_p_cf))>=1) ) # two tight leptons, at least one electron charge flip cf_est_sel_data = (baseline & ~baseline) # this has to be false weight_np_mc = self.nonpromptWeight.get(el_f_np, mu_f_np, meas='TT') weight_cf_mc = self.chargeflipWeight.flip_weight(el_t_p) else: BL = (baseline & ((ak.num(el_t)+ak.num(mu_t))==2)) BL_incl = BL np_est_sel_mc = (baseline & ~baseline) np_obs_sel_mc = (baseline & ~baseline) np_est_sel_data = (baseline & (ak.num(el_t)+ak.num(mu_t)==1) & (ak.num(el_f)+ak.num(mu_f)==1) ) cf_est_sel_mc = (baseline & ~baseline) cf_obs_sel_mc = (baseline & ~baseline) cf_est_sel_data = (baseline_OS & ((ak.num(el_t)+ak.num(mu_t))==2) ) weight_np_mc = np.zeros(len(ev)) weight_cf_mc = np.zeros(len(ev)) #rle = ak.to_numpy(ak.zip([ev.run, ev.luminosityBlock, ev.event])) run_ = ak.to_numpy(ev.run) lumi_ = ak.to_numpy(ev.luminosityBlock) event_ = ak.to_numpy(ev.event) if False: output['%s_run'%dataset] += processor.column_accumulator(run_[BL]) output['%s_lumi'%dataset] += processor.column_accumulator(lumi_[BL]) output['%s_event'%dataset] += processor.column_accumulator(event_[BL]) weight_BL = weight.weight()[BL] # this is just a shortened weight list for the two prompt selection weight_np_data = self.nonpromptWeight.get(el_f, mu_f, meas='data') weight_cf_data = self.chargeflipWeight.flip_weight(el_t) out_sel = (BL | np_est_sel_mc | cf_est_sel_mc) dummy = (np.ones(len(ev))==1) def fill_multiple_np(hist, arrays, add_sel=dummy): #reg_sel = [BL, np_est_sel_mc, np_obs_sel_mc, np_est_sel_data, cf_est_sel_mc, cf_obs_sel_mc, cf_est_sel_data], #print ('len', len(reg_sel[0])) #print ('sel', reg_sel[0]) reg_sel = [BL&add_sel, BL_incl&add_sel, np_est_sel_mc&add_sel, np_obs_sel_mc&add_sel, np_est_sel_data&add_sel, cf_est_sel_mc&add_sel, cf_obs_sel_mc&add_sel, cf_est_sel_data&add_sel], fill_multiple( hist, datasets=[ dataset, # only prompt contribution from process dataset+"_incl", # everything from process (inclusive MC truth) "np_est_mc", # MC based NP estimate "np_obs_mc", # MC based NP observation "np_est_data", "cf_est_mc", "cf_obs_mc", "cf_est_data", ], arrays=arrays, selections=reg_sel[0], # no idea where the additional dimension is coming from... weights=[ weight.weight()[reg_sel[0][0]], weight.weight()[reg_sel[0][1]], weight.weight()[reg_sel[0][2]]*weight_np_mc[reg_sel[0][2]], weight.weight()[reg_sel[0][3]], weight.weight()[reg_sel[0][4]]*weight_np_data[reg_sel[0][4]], weight.weight()[reg_sel[0][5]]*weight_cf_mc[reg_sel[0][5]], weight.weight()[reg_sel[0][6]], weight.weight()[reg_sel[0][7]]*weight_cf_data[reg_sel[0][7]], ], ) if self.evaluate or self.dump: # define the inputs to the NN # this is super stupid. there must be a better way. # used a np.stack which is ok performance wise. pandas data frame seems to be slow and memory inefficient #FIXME no n_b, n_fwd back in v13/v14 of the DNN NN_inputs_d = { 'n_jet': ak.to_numpy(ak.num(jet)), 'n_fwd': ak.to_numpy(ak.num(fwd)), 'n_b': ak.to_numpy(ak.num(btag)), 'n_tau': ak.to_numpy(ak.num(tau)), #'n_track': ak.to_numpy(ak.num(track)), 'st': ak.to_numpy(st), 'met': ak.to_numpy(ev.MET.pt), 'mjj_max': ak.to_numpy(ak.fill_none(ak.max(mjf, axis=1),0)), 'delta_eta_jj': ak.to_numpy(pad_and_flatten(delta_eta)), 'lead_lep_pt': ak.to_numpy(pad_and_flatten(leading_lepton.p4.pt)), 'lead_lep_eta': ak.to_numpy(pad_and_flatten(leading_lepton.p4.eta)), 'sublead_lep_pt': ak.to_numpy(pad_and_flatten(trailing_lepton.p4.pt)), 'sublead_lep_eta': ak.to_numpy(pad_and_flatten(trailing_lepton.p4.eta)), 'dilepton_mass': ak.to_numpy(pad_and_flatten(dilepton_mass)), 'dilepton_pt': ak.to_numpy(pad_and_flatten(dilepton_pt)), 'fwd_jet_pt': ak.to_numpy(pad_and_flatten(best_fwd.pt)), 'fwd_jet_p': ak.to_numpy(pad_and_flatten(best_fwd.p)), 'fwd_jet_eta': ak.to_numpy(pad_and_flatten(best_fwd.eta)), 'lead_jet_pt': ak.to_numpy(pad_and_flatten(jet[:, 0:1].pt)), 'sublead_jet_pt': ak.to_numpy(pad_and_flatten(jet[:, 1:2].pt)), 'lead_jet_eta': ak.to_numpy(pad_and_flatten(jet[:, 0:1].eta)), 'sublead_jet_eta': ak.to_numpy(pad_and_flatten(jet[:, 1:2].eta)), 'lead_btag_pt': ak.to_numpy(pad_and_flatten(high_score_btag[:, 0:1].pt)), 'sublead_btag_pt': ak.to_numpy(pad_and_flatten(high_score_btag[:, 1:2].pt)), 'lead_btag_eta': ak.to_numpy(pad_and_flatten(high_score_btag[:, 0:1].eta)), 'sublead_btag_eta': ak.to_numpy(pad_and_flatten(high_score_btag[:, 1:2].eta)), 'min_bl_dR': ak.to_numpy(ak.fill_none(min_bl_dR, 0)), 'min_mt_lep_met': ak.to_numpy(ak.fill_none(min_mt_lep_met, 0)), } if self.dump: for k in NN_inputs_d.keys(): output[k] += processor.column_accumulator(NN_inputs_d[k][out_sel]) if self.evaluate: NN_inputs = np.stack( [NN_inputs_d[k] for k in NN_inputs_d.keys()] ) NN_inputs = np.nan_to_num(NN_inputs, 0, posinf=1e5, neginf=-1e5) # events with posinf/neginf/nan will not pass the BL selection anyway NN_inputs = np.moveaxis(NN_inputs, 0, 1) # this is needed for a np.stack (old version) model, scaler = load_onnx_model(self.training) try: NN_inputs_scaled = scaler.transform(NN_inputs) NN_pred = predict_onnx(model, NN_inputs_scaled) best_score = np.argmax(NN_pred, axis=1) except ValueError: print ("Problem with prediction. Showing the shapes here:") print (np.shape(NN_inputs)) print (np.shape(weight_BL)) NN_pred = np.array([]) best_score = np.array([]) NN_inputs_scaled = NN_inputs raise ##k.clear_session() #FIXME below needs to be fixed again with changed NN evaluation. Should work now fill_multiple_np(output['node'], {'multiplicity':best_score}) fill_multiple_np(output['node0_score_incl'], {'score':NN_pred[:,0]}) fill_multiple_np(output['node1_score_incl'], {'score':NN_pred[:,1]}) fill_multiple_np(output['node2_score_incl'], {'score':NN_pred[:,2]}) fill_multiple_np(output['node3_score_incl'], {'score':NN_pred[:,3]}) fill_multiple_np(output['node4_score_incl'], {'score':NN_pred[:,4]}) fill_multiple_np(output['node0_score'], {'score':NN_pred[:,0]}, add_sel=(best_score==0)) fill_multiple_np(output['node1_score'], {'score':NN_pred[:,1]}, add_sel=(best_score==1)) fill_multiple_np(output['node2_score'], {'score':NN_pred[:,2]}, add_sel=(best_score==2)) fill_multiple_np(output['node3_score'], {'score':NN_pred[:,3]}, add_sel=(best_score==3)) fill_multiple_np(output['node4_score'], {'score':NN_pred[:,4]}, add_sel=(best_score==4)) #SR_sel_pp = ((best_score==0) & ak.flatten((leading_lepton[BL].pdgId<0))) #SR_sel_mm = ((best_score==0) & ak.flatten((leading_lepton[BL].pdgId>0))) #leading_lepton_BL = leading_lepton[BL] #output['lead_lep_SR_pp'].fill( # dataset = dataset, # pt = ak.to_numpy(ak.flatten(leading_lepton_BL[SR_sel_pp].pt)), # weight = weight_BL[SR_sel_pp] #) #output['lead_lep_SR_mm'].fill( # dataset = dataset, # pt = ak.to_numpy(ak.flatten(leading_lepton_BL[SR_sel_mm].pt)), # weight = weight_BL[SR_sel_mm] #) del model del scaler del NN_inputs, NN_inputs_scaled, NN_pred labels = {'topW_v3': 0, 'TTW':1, 'TTZ': 2, 'TTH': 3, 'ttbar': 4, 'rare':5, 'diboson':6} # these should be all? if dataset in labels: label_mult = labels[dataset] else: label_mult = 7 # data or anything else if self.dump: output['label'] += processor.column_accumulator(np.ones(len(ev[out_sel])) * label_mult) output['SS'] += processor.column_accumulator(ak.to_numpy(BL[out_sel])) output['OS'] += processor.column_accumulator(ak.to_numpy(cf_est_sel_mc[out_sel])) output['AR'] += processor.column_accumulator(ak.to_numpy(np_est_sel_mc[out_sel])) output['LL'] += processor.column_accumulator(ak.to_numpy(LL[out_sel])) output['weight'] += processor.column_accumulator(ak.to_numpy(weight.weight()[out_sel])) output['weight_np'] += processor.column_accumulator(ak.to_numpy(weight_np_mc[out_sel])) output['weight_cf'] += processor.column_accumulator(ak.to_numpy(weight_cf_mc[out_sel])) # first, make a few super inclusive plots output['PV_npvs'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvs, weight=weight_BL) output['PV_npvsGood'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvsGood, weight=weight_BL) fill_multiple_np(output['N_jet'], {'multiplicity': ak.num(jet)}) fill_multiple_np(output['N_b'], {'multiplicity': ak.num(btag)}) fill_multiple_np(output['N_central'], {'multiplicity': ak.num(central)}) fill_multiple_np(output['N_ele'], {'multiplicity':ak.num(electron)}) fill_multiple_np(output['N_mu'], {'multiplicity':ak.num(muon)}) fill_multiple_np(output['N_fwd'], {'multiplicity':ak.num(fwd)}) fill_multiple_np(output['ST'], {'ht': st}) fill_multiple_np(output['HT'], {'ht': ht}) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): output['nLepFromTop'].fill(dataset=dataset, multiplicity=ev[BL].nLepFromTop, weight=weight_BL) output['nLepFromTau'].fill(dataset=dataset, multiplicity=ev.nLepFromTau[BL], weight=weight_BL) output['nLepFromZ'].fill(dataset=dataset, multiplicity=ev.nLepFromZ[BL], weight=weight_BL) output['nLepFromW'].fill(dataset=dataset, multiplicity=ev.nLepFromW[BL], weight=weight_BL) output['nGenTau'].fill(dataset=dataset, multiplicity=ev.nGenTau[BL], weight=weight_BL) output['nGenL'].fill(dataset=dataset, multiplicity=ak.num(ev.GenL[BL], axis=1), weight=weight_BL) output['chargeFlip_vs_nonprompt'].fill(dataset=dataset, n1=n_chargeflip[BL], n2=n_nonprompt[BL], n_ele=ak.num(electron)[BL], weight=weight_BL) fill_multiple_np(output['MET'], {'pt':ev.MET.pt, 'phi':ev.MET.phi}) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): output['lead_gen_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_gen_lep[BL].pt)), eta = ak.to_numpy(ak.flatten(leading_gen_lep[BL].eta)), phi = ak.to_numpy(ak.flatten(leading_gen_lep[BL].phi)), weight = weight_BL ) output['trail_gen_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].pt)), eta = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].eta)), phi = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].phi)), weight = weight_BL ) fill_multiple_np( output['lead_lep'], { 'pt': pad_and_flatten(leading_lepton.p4.pt), 'eta': pad_and_flatten(leading_lepton.eta), 'phi': pad_and_flatten(leading_lepton.phi), }, ) fill_multiple_np( output['trail_lep'], { 'pt': pad_and_flatten(trailing_lepton.p4.pt), 'eta': pad_and_flatten(trailing_lepton.eta), 'phi': pad_and_flatten(trailing_lepton.phi), }, ) output['j1'].fill( dataset = dataset, pt = ak.flatten(jet.pt_nom[:, 0:1][BL]), eta = ak.flatten(jet.eta[:, 0:1][BL]), phi = ak.flatten(jet.phi[:, 0:1][BL]), weight = weight_BL ) output['j2'].fill( dataset = dataset, pt = ak.flatten(jet[:, 1:2][BL].pt_nom), eta = ak.flatten(jet[:, 1:2][BL].eta), phi = ak.flatten(jet[:, 1:2][BL].phi), weight = weight_BL ) output['j3'].fill( dataset = dataset, pt = ak.flatten(jet[:, 2:3][BL].pt_nom), eta = ak.flatten(jet[:, 2:3][BL].eta), phi = ak.flatten(jet[:, 2:3][BL].phi), weight = weight_BL ) fill_multiple_np( output['fwd_jet'], { 'pt': pad_and_flatten(best_fwd.pt), 'eta': pad_and_flatten(best_fwd.eta), 'phi': pad_and_flatten(best_fwd.phi), }, ) #output['fwd_jet'].fill( # dataset = dataset, # pt = ak.flatten(j_fwd[BL].pt), # eta = ak.flatten(j_fwd[BL].eta), # phi = ak.flatten(j_fwd[BL].phi), # weight = weight_BL #) output['high_p_fwd_p'].fill(dataset=dataset, p = ak.flatten(best_fwd[BL].p), weight = weight_BL) return output
def normalize(val, cut): return ak.to_numpy(ak.fill_none(val[cut], np.nan))
def __init__(self, ev, obj, wp, verbose=0, year=2018): self.obj = obj self.wp = wp if self.wp == None: self.selection_dict = {} else: self.selection_dict = obj_def[self.obj][self.wp] self.v = verbose #self.year = df['year'][0] ## to be implemented in next verison of babies self.year = year if self.obj == "Muon": # collections are already there, so we just need to calculate missing ones ev['Muon', 'absMiniIso'] = ev.Muon.miniPFRelIso_all * ev.Muon.pt ev['Muon', 'ptErrRel'] = ev.Muon.ptErr / ev.Muon.pt # this is what we are using: # - jetRelIso if the matched jet is within deltaR<0.4, pfRelIso03_all otherwise # - btagDeepFlavB discriminator of the matched jet if jet is within deltaR<0.4, 0 otherwise # (FOR TTH) - pt_cone = 0.9*pt of matched jet if jet is within deltaR<0.4, pt/(pt+iso) otherwise # (FOR SS) - pt_cone = pt*(1 + max(0,I_m-I_1)) if pt_rel > I_3; max(pt, pt(matched_jet)*I_2) otherwise #TTH conePt mask_close = (ak.fill_none(ev.Muon.delta_r(ev.Muon.matched_jet), 99) < 0.4) * 1 mask_far = ~(ak.fill_none(ev.Muon.delta_r(ev.Muon.matched_jet), 99) < 0.4) * 1 #conePt = 0.9 * ak.fill_none(ev.Muon.matched_jet.pt,0) * mask_close + ev.Muon.pt*(1 + ev.Muon.miniPFRelIso_all)*mask_far #SS conePt if (self.year == 2017) or (self.year == 2018): I_1 = 0.11 I_2 = 0.74 I_3 = 6.8 elif (self.year == 2016): I_1 = 0.16 I_2 = 0.76 I_3 = 7.2 PF_unflatten = ak.from_regular( ev.Muon.miniPFRelIso_all[:, :, np.newaxis]) max_miniIso = ak.max( ak.concatenate( [PF_unflatten - I_1, ak.zeros_like(PF_unflatten)], axis=2), axis=2) #equivalent to max(0, ev.Muon.miniPFRelIso_all - I_1) muon_pt_unflatten = ak.from_regular(ev.Muon.pt[:, :, np.newaxis]) jet_pt_unflatten = ak.from_regular( ev.Muon.matched_jet.pt[:, :, np.newaxis]) max_pt = ak.max( ak.concatenate([muon_pt_unflatten, jet_pt_unflatten * I_2], axis=2), axis=2) #max(ev.Muon.pt, ev.Muon.matched_jet.pt * I_2) conePt = (ev.Muon.pt * (1 + max_miniIso)) * (ev.Muon.jetPtRelv2 > I_3) + ( max_pt * ~(ev.Muon.jetPtRelv2 > I_3)) deepJet = ak.fill_none(ev.Muon.matched_jet.btagDeepFlavB, 0) * mask_close jetRelIsoV2 = ev.Muon.jetRelIso * mask_close + ev.Muon.pfRelIso03_all * mask_far # default to 0 if no match ev['Muon', 'deepJet'] = ak.copy(deepJet) ev['Muon', 'jetRelIsoV2'] = jetRelIsoV2 ev['Muon', 'conePt'] = conePt ev['Muon', 'jetRelIso'] = ev.Muon.jetRelIso ev['Muon', 'jetPtRelv2'] = ev.Muon.jetPtRelv2 ev['Muon', 'boolFCNCIso'] = self.getFCNCIsolation( ev.Muon.jetRelIso, ev.Muon.jetPtRelv2, I_2, I_3) & (ev.Muon.miniPFRelIso_all < I_1) ev['Muon', 'boolFCNCfake'] = (ev.Muon.genPartFlav != 1) & (ev.Muon.genPartFlav != 15) self.cand = ev.Muon elif self.obj == "Electron": # calculate new variables. asignment is awkward, but what can you do. ev['Electron', 'absMiniIso'] = ev.Electron.miniPFRelIso_all * ev.Electron.pt ev['Electron', 'etaSC'] = ev.Electron.eta + ev.Electron.deltaEtaSC # the following line is only needed if we do our own matching. # right now, we keep using the NanoAOD match, but check the deltaR distance # jet_index, mask_match, mask_nomatch = self.matchJets(ev.Electron, ev.Jet) # this is what we are using: # - jetRelIso if the matched jet is within deltaR<0.4, pfRelIso03_all otherwise # - btagDeepFlavB discriminator of the matched jet if jet is within deltaR<0.4, 0 otherwise # - pt_cone = 0.9*pt of matched jet if jet is within deltaR<0.4, pt/(pt+iso), 0 otherwise mask_close = (ak.fill_none( ev.Electron.delta_r(ev.Electron.matched_jet), 99) < 0.4) * 1 mask_far = ~(ak.fill_none( ev.Electron.delta_r(ev.Electron.matched_jet), 99) < 0.4) * 1 deepJet = ak.fill_none(ev.Electron.matched_jet.btagDeepFlavB, 0) * mask_close jetRelIsoV2 = ev.Electron.jetRelIso * mask_close + ev.Electron.pfRelIso03_all * mask_far # default to 0 if no match #TTH conePt #conePt = 0.9 * ak.fill_none(ev.Electron.matched_jet.pt,0) * mask_close + ev.Electron.pt*(1 + ev.Electron.miniPFRelIso_all)*mask_far #SS conePt if (self.year == 2017) or (self.year == 2018): I_1 = 0.07 I_2 = 0.78 I_3 = 8.0 elif (self.year == 2016): I_1 = 0.12 I_2 = 0.8 I_3 = 7.2 PF_unflatten = ak.from_regular( ev.Electron.miniPFRelIso_all[:, :, np.newaxis]) max_miniIso = ak.max( ak.concatenate( [PF_unflatten - I_1, ak.zeros_like(PF_unflatten)], axis=2), axis=2) #equivalent to max(0, ev.Muon.miniPFRelIso_all - I_1) electron_pt_unflatten = ak.from_regular(ev.Electron.pt[:, :, np.newaxis]) jet_pt_unflatten = ak.from_regular( ev.Electron.matched_jet.pt[:, :, np.newaxis]) max_pt = ak.max( ak.concatenate([electron_pt_unflatten, jet_pt_unflatten * I_2], axis=2), axis=2) #max(ev.Muon.pt, ev.Muon.matched_jet.pt * I_2) conePt = (ev.Electron.pt * (1 + max_miniIso)) * (ev.Electron.jetPtRelv2 > I_3) + ( max_pt * ~(ev.Electron.jetPtRelv2 > I_3)) ev['Electron', 'deepJet'] = ak.copy(deepJet) ev['Electron', 'jetRelIsoV2'] = jetRelIsoV2 ev['Electron', 'conePt'] = conePt ev['Electron', 'jetRelIso'] = ev.Electron.jetRelIso ev['Electron', 'jetPtRelv2'] = ev.Electron.jetPtRelv2 ev['Electron', 'boolFCNCIso'] = self.getFCNCIsolation( ev.Electron.jetRelIso, ev.Electron.jetPtRelv2, I_2, I_3) & (ev.Electron.miniPFRelIso_all < I_1) ev['Electron', 'boolFCNCfake'] = (ev.Electron.genPartFlav != 1) & (ev.Electron.genPartFlav != 15) self.cand = ev.Electron self.getSelection() if self.obj == "Electron" and self.wp == "tight": self.selection = self.selection & self.getElectronMVAID( ) & self.getIsolation(0.07, 0.78, 8.0) & self.isTriggerSafeNoIso() if self.v > 0: print(" - custom ID and multi-isolation") if self.obj == "Muon" and self.wp == "tight": self.selection = self.selection & self.getIsolation( 0.11, 0.74, 6.8) if self.v > 0: print(" - custom multi-isolation") #self.selection = self.selection & ak.fill_none(ev.Muon.matched_jet.btagDeepFlavB<0.2770, True) #self.selection = self.selection & (ev.Muon.matched_jet.btagDeepFlavB<0.2770) #if self.v>0: print (" - deepJet") if self.obj == "Electron" and (self.wp == "tightTTH" or self.wp == 'fakeableTTH' or self.wp == "tightSSTTH" or self.wp == 'fakeableSSTTH'): self.selection = self.selection & self.getSigmaIEtaIEta() if self.v > 0: print(" - SigmaIEtaIEta") #self.selection = self.selection & ak.fill_none(ev.Electron.matched_jet.btagDeepFlavB<0.2770, True) #self.selection = self.selection & (ev.Electron.matched_jet.btagDeepFlavB<0.2770) #self.selection = self.selection & (ev.Jet[ev.Electron.jetIdx].btagDeepFlavB<0.2770) #if self.v>0: print (" - deepJet") if self.obj == 'Muon' and (self.wp == 'fakeableTTH' or self.wp == 'fakeableSSTTH'): self.selection = self.selection & ( self.cand.deepJet < self.getThreshold(self.cand.conePt, min_pt=20, max_pt=45, low=0.2770, high=0.0494)) if self.v > 0: print(" - interpolated deepJet")
def num(ar): return ak.num(ak.fill_none(ar[~ak.is_none(ar)], 0), axis=0)
def process(self, events): output = self.accumulator.identity() # use a very loose preselection to filter the events presel = ak.num(events.Jet)>2 ev = events[presel] dataset = ev.metadata['dataset'] # load the config - probably not needed anymore cfg = loadConfig() output['totalEvents']['all'] += len(events) output['skimmedEvents']['all'] += len(ev) ## Generated leptons gen_lep = ev.GenL leading_gen_lep = gen_lep[ak.singletons(ak.argmax(gen_lep.pt, axis=1))] trailing_gen_lep = gen_lep[ak.singletons(ak.argmin(gen_lep.pt, axis=1))] ## Muons muon = Collections(ev, "Muon", "tightTTH").get() vetomuon = Collections(ev, "Muon", "vetoTTH").get() leading_muon_idx = ak.singletons(ak.argmax(muon.pt, axis=1)) leading_muon = muon[leading_muon_idx] ## Electrons electron = Collections(ev, "Electron", "tightTTH").get() vetoelectron = Collections(ev, "Electron", "vetoTTH").get() leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1)) leading_electron = electron[leading_electron_idx] ## Merge electrons and muons - this should work better now in ak1 dilepton = cross(muon, electron) dimuon = choose(muon,2) OS_dimuon = dimuon[(dimuon['0'].charge*dimuon['1'].charge < 0)] dielectron = choose(electron) OS_dielectron = dielectron[(dielectron['0'].charge*dielectron['1'].charge < 0)] OS_dimuon_bestZmumu = OS_dimuon[ak.singletons(ak.argmin(abs(OS_dimuon.mass-91.2), axis=1))] OS_dielectron_bestZee = OS_dielectron[ak.singletons(ak.argmin(abs(OS_dielectron.mass-91.2), axis=1))] OS_dilepton_mass = ak.fill_none(ak.pad_none(ak.concatenate([OS_dimuon_bestZmumu.mass, OS_dielectron_bestZee.mass], axis=1), 1, clip=True), -1) lepton = ak.concatenate([muon, electron], axis=1) leading_lepton_idx = ak.singletons(ak.argmax(lepton.pt, axis=1)) leading_lepton = lepton[leading_lepton_idx] trailing_lepton_idx = ak.singletons(ak.argmin(lepton.pt, axis=1)) trailing_lepton = lepton[trailing_lepton_idx] ## Jets jet = getJets(ev, minPt=25, maxEta=4.7, pt_var='pt_nom') jet = jet[ak.argsort(jet.pt_nom, ascending=False)] # need to sort wrt smeared and recorrected jet pt jet = jet[~match(jet, muon, deltaRCut=0.4)] # remove jets that overlap with muons jet = jet[~match(jet, electron, deltaRCut=0.4)] # remove jets that overlap with electrons central = jet[(abs(jet.eta)<2.4)] btag = getBTagsDeepFlavB(jet, year=self.year) # should study working point for DeepJet light = getBTagsDeepFlavB(jet, year=self.year, invert=True) fwd = getFwdJet(light) fwd_noPU = getFwdJet(light, puId=False) ## forward jets j_fwd = fwd[ak.singletons(ak.argmax(fwd.p, axis=1))] # highest momentum spectator jf = cross(j_fwd, jet) mjf = (jf['0']+jf['1']).mass j_fwd2 = jf[ak.singletons(ak.argmax(mjf, axis=1))]['1'] # this is the jet that forms the largest invariant mass with j_fwd delta_eta = abs(j_fwd2.eta - j_fwd.eta) ## MET -> can switch to puppi MET met_pt = ev.MET.pt met_phi = ev.MET.phi ## other variables ht = ak.sum(jet.pt, axis=1) st = met_pt + ht + ak.sum(muon.pt, axis=1) + ak.sum(electron.pt, axis=1) # define the weight weight = Weights( len(ev) ) if not dataset=='MuonEG': # lumi weight weight.add("weight", ev.weight*cfg['lumi'][self.year]) #weight.add("weight", ev.genWeight*cfg['lumi'][self.year]*mult) # PU weight - not in the babies... weight.add("PU", ev.puWeight, weightUp=ev.puWeightUp, weightDown=ev.puWeightDown, shift=False) # b-tag SFs weight.add("btag", self.btagSF.Method1a(btag, light)) ## lepton SFs #weight.add("lepton", self.leptonSF.get(electron, muon)) cutflow = Cutflow(output, ev, weight=weight) sel = Selection( dataset = dataset, events = ev, year = self.year, ele = electron, ele_veto = vetoelectron, mu = muon, mu_veto = vetomuon, jet_all = jet, jet_central = central, jet_btag = btag, jet_fwd = fwd, met = ev.MET, ) BL = sel.trilep_baseline(cutflow=cutflow) # first, make a few super inclusive plots output['PV_npvs'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvs, weight=weight.weight()[BL]) output['PV_npvsGood'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvsGood, weight=weight.weight()[BL]) output['N_jet'].fill(dataset=dataset, multiplicity=ak.num(jet)[BL], weight=weight.weight()[BL]) output['N_b'].fill(dataset=dataset, multiplicity=ak.num(btag)[BL], weight=weight.weight()[BL]) output['N_central'].fill(dataset=dataset, multiplicity=ak.num(central)[BL], weight=weight.weight()[BL]) output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(electron)[BL], weight=weight.weight()[BL]) output['N_mu'].fill(dataset=dataset, multiplicity=ak.num(electron)[BL], weight=weight.weight()[BL]) output['N_fwd'].fill(dataset=dataset, multiplicity=ak.num(fwd)[BL], weight=weight.weight()[BL]) output['nLepFromTop'].fill(dataset=dataset, multiplicity=ev[BL].nLepFromTop, weight=weight.weight()[BL]) output['nLepFromTau'].fill(dataset=dataset, multiplicity=ev.nLepFromTau[BL], weight=weight.weight()[BL]) output['nLepFromZ'].fill(dataset=dataset, multiplicity=ev.nLepFromZ[BL], weight=weight.weight()[BL]) output['nLepFromW'].fill(dataset=dataset, multiplicity=ev.nLepFromW[BL], weight=weight.weight()[BL]) output['nGenTau'].fill(dataset=dataset, multiplicity=ev.nGenTau[BL], weight=weight.weight()[BL]) output['nGenL'].fill(dataset=dataset, multiplicity=ak.num(ev.GenL[BL], axis=1), weight=weight.weight()[BL]) # make a plot of the dilepton mass, but without applying the cut on the dilepton mass itself (N-1 plot) output['dilep_mass'].fill(dataset=dataset, mass=ak.flatten(OS_dilepton_mass[sel.trilep_baseline(omit=['offZ'])]), weight=weight.weight()[sel.trilep_baseline(omit=['offZ'])]) output['MET'].fill( dataset = dataset, pt = ev.MET[BL].pt, phi = ev.MET[BL].phi, weight = weight.weight()[BL] ) output['lead_gen_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_gen_lep[BL].pt)), eta = ak.to_numpy(ak.flatten(leading_gen_lep[BL].eta)), phi = ak.to_numpy(ak.flatten(leading_gen_lep[BL].phi)), weight = weight.weight()[BL] ) output['trail_gen_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].pt)), eta = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].eta)), phi = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].phi)), weight = weight.weight()[BL] ) output['lead_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_lepton[BL].pt)), eta = ak.to_numpy(ak.flatten(leading_lepton[BL].eta)), phi = ak.to_numpy(ak.flatten(leading_lepton[BL].phi)), weight = weight.weight()[BL] ) output['trail_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(trailing_lepton[BL].pt)), eta = ak.to_numpy(ak.flatten(trailing_lepton[BL].eta)), phi = ak.to_numpy(ak.flatten(trailing_lepton[BL].phi)), weight = weight.weight()[BL] ) output['j1'].fill( dataset = dataset, pt = ak.flatten(jet.pt_nom[:, 0:1][BL]), eta = ak.flatten(jet.eta[:, 0:1][BL]), phi = ak.flatten(jet.phi[:, 0:1][BL]), weight = weight.weight()[BL] ) output['j2'].fill( dataset = dataset, pt = ak.flatten(jet[:, 1:2][BL].pt_nom), eta = ak.flatten(jet[:, 1:2][BL].eta), phi = ak.flatten(jet[:, 1:2][BL].phi), weight = weight.weight()[BL] ) #output['j3'].fill( # dataset = dataset, # pt = ak.flatten(jet[:, 2:3][BL].pt_nom), # eta = ak.flatten(jet[:, 2:3][BL].eta), # phi = ak.flatten(jet[:, 2:3][BL].phi), # weight = weight.weight()[BL] #) output['fwd_jet'].fill( dataset = dataset, pt = ak.flatten(j_fwd[BL].pt), eta = ak.flatten(j_fwd[BL].eta), phi = ak.flatten(j_fwd[BL].phi), weight = weight.weight()[BL] ) output['high_p_fwd_p'].fill(dataset=dataset, p = ak.flatten(j_fwd[BL].p), weight = weight.weight()[BL]) return output
def process(self, events): output = self._accumulator.identity() dataset_name = events.metadata['dataset'] output["total_events"][dataset_name] += events.__len__() # HLT selection HLT_mask = [] if year == "2016": if "SingleMuon" in dataset_name: #this does not work, as the name of file which is under processing is unknown if "2016B2" in dataset_name: HLT_mask = events.HLT.IsoMu24 | events.HLT.IsoTkMu24 | events.HLT.Mu50 else: HLT_mask = events.HLT.IsoMu24 | events.HLT.IsoTkMu24 | events.HLT.Mu50 | events.HLT.TkMu50 else: #https://twiki.cern.ch/twiki/bin/view/CMS/HLTPathsRunIIList if "2016B2" in dataset_name: HLT_mask = events.HLT.PFHT800 | events.HLT.PFHT900 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID elif "2016H" in dataset_name: HLT_mask = events.HLT.PFHT900 | events.HLT.AK8PFJet450 | events.HLT.AK8PFJet500 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID else: HLT_mask = events.HLT.PFHT800 | events.HLT.PFHT900 | events.HLT.AK8PFJet450 | events.HLT.AK8PFJet500 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID if year == "2017": if "SingleMuon" in dataset_name: if "2017B" in dataset_name: HLT_mask = events.HLT.IsoMu27 | events.HLT.Mu50 else: HLT_mask = events.HLT.IsoMu27 | events.HLT.Mu50 | events.HLT.OldMu100 | events.HLT.TkMu100 else: HLT_mask = events.HLT.PFHT1050 | events.HLT.AK8PFJet500 | events.HLT.AK8PFJet550 | events.HLT.CaloJet500_NoJetID | events.HLT.CaloJet550_NoJetID | events.HLT.PFJet500 if year == "2018": if "SingleMuon" in dataset_name: HLT_mask = events.HLT.IsoMu24 | events.HLT.Mu50 | events.HLT.OldMu100 | events.HLT.TkMu100 else: HLT_mask = events.HLT.PFHT1050 | events.HLT.AK8PFJet500 | events.HLT.AK8PFJet550 | events.HLT.CaloJet500_NoJetID | events.HLT.CaloJet550_NoJetID | events.HLT.PFJet500 # Require 3 jets jet_mask = (events.Jet.pt > 30.) & (abs(events.Jet.eta) < 2.5) & (events.Jet.isTight) event_mask = (awk.sum(jet_mask, axis=1) >= 3) event_mask = event_mask & HLT_mask events_3j = events[event_mask] # Reduce jet mask to only events with 3 good jets jet_mask = jet_mask[event_mask] # Array of the jets to consider for trijet resonance selected_jets = events_3j.Jet[jet_mask][:, :3] # Pairs of jets #pairs = awk.argcombinations(selected_jets, 2) #jet_i, jet_j = awk.unzip(pairs) pairs = [(0, 1), (1, 2), (2, 0)] jet_i, jet_j = zip(*pairs) # Returns [0, 1, 2] , [1, 2, 0] m_ij = (selected_jets[:, jet_i] + selected_jets[:, jet_j]).mass dR_ij = selected_jets[:, jet_i].delta_r(selected_jets[:, jet_j]) dEta_ij = abs(selected_jets[:, jet_i].eta - selected_jets[:, jet_j].eta) jet_k = [2, 0, 1] dR_i_jk = selected_jets[:, jet_i].delta_r(selected_jets[:, jet_j] + selected_jets[:, jet_k]) dEta_i_jk = abs(selected_jets[:, jet_i].eta - (selected_jets[:, jet_j] + selected_jets[:, jet_k]).eta) dPhi_i_jk = abs(selected_jets[:, jet_i].phi - (selected_jets[:, jet_j] + selected_jets[:, jet_k]).phi) m3j = selected_jets.sum().mass pt_i_overM = selected_jets.pt / m3j m_01_overM = m_ij[:, 0] / m3j m_12_overM = m_ij[:, 1] / m3j m_20_overM = m_ij[:, 2] / m3j dPtoverM_0_12 = abs(selected_jets[:, 0].pt - (selected_jets[:, 1] + selected_jets[:, 2]).pt) / m3j dPtoverM_1_20 = abs(selected_jets[:, 1].pt - (selected_jets[:, 2] + selected_jets[:, 0]).pt) / m3j dPtoverM_2_01 = abs(selected_jets[:, 2].pt - (selected_jets[:, 0] + selected_jets[:, 1]).pt) / m3j # Event selection masks selection_masks = {} # Pre-selection selection = PackedSelection() selection.add("Dummy", m3j > 000) sel_mask = selection.require( **{name: True for name in selection.names}) selection_masks["Pre-selection"] = sel_mask # HLT_trigger (this is already done at the beginning) # if year == "2016": # JetHLT_mask = [] # if "2016B2" in dataset_name: # JetHLT_mask = events.HLT.PFHT800 | events.HLT.PFHT900 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID # elif "2016H" in dataset_name: # JetHLT_mask = events.HLT.PFHT900 | events.HLT.AK8PFJet450 | events.HLT.AK8PFJet500 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID # else: # JetHLT_mask = events.HLT.PFHT800 | events.HLT.PFHT900 | events.HLT.AK8PFJet450 | events.HLT.AK8PFJet500 | events.HLT.PFJet500 | events.HLT.CaloJet500_NoJetID # selection_masks["JetHLT"] = JetHLT_mask[event_mask] # if year == "2017": # JetHLT_mask = events.HLT.PFHT1050 | events.HLT.AK8PFJet500 | events.HLT.AK8PFJet550 | events.HLT.CaloJet500_NoJetID | events.HLT.CaloJet550_NoJetID | events.HLT.PFJet500 # selection_masks["JetHLT"] = JetHLT_mask[event_mask] # if year == "2018": # JetHLT_mask = events.HLT.PFHT1050 | events.HLT.AK8PFJet500 | events.HLT.AK8PFJet550 | events.HLT.CaloJet500_NoJetID | events.HLT.CaloJet550_NoJetID | events.HLT.PFJet500 # selection_masks["JetHLT"] = JetHLT_mask[event_mask] # Fill histograms for selection, selection_mask in selection_masks.items(): output["mjjj"].fill(dataset=dataset_name, selection=selection, mjjj=m3j[selection_mask]) output["m_ij"].fill(dataset=dataset_name, selection=selection, m_01=m_ij[:, 0][selection_mask], m_12=m_ij[:, 1][selection_mask], m_20=m_ij[:, 2][selection_mask]) output["dR_ij"].fill(dataset=dataset_name, selection=selection, dR_01=dR_ij[:, 0][selection_mask], dR_12=dR_ij[:, 1][selection_mask], dR_20=dR_ij[:, 2][selection_mask]) output["dEta_ij"].fill(dataset=dataset_name, selection=selection, dEta_01=dEta_ij[:, 0][selection_mask], dEta_12=dEta_ij[:, 1][selection_mask], dEta_20=dEta_ij[:, 2][selection_mask]) output["moverM_ij"].fill(dataset=dataset_name, selection=selection, moverM_01=m_01_overM[selection_mask], moverM_12=m_12_overM[selection_mask], moverM_20=m_20_overM[selection_mask]) output["pt_i"].fill(dataset=dataset_name, selection=selection, pt_0=selected_jets[:, 0][selection_mask].pt, pt_1=selected_jets[:, 1][selection_mask].pt, pt_2=selected_jets[:, 2][selection_mask].pt) output["eta_i"].fill(dataset=dataset_name, selection=selection, eta_0=selected_jets[:, 0][selection_mask].eta, eta_1=selected_jets[:, 1][selection_mask].eta, eta_2=selected_jets[:, 2][selection_mask].eta) output["ptoverM_i"].fill(dataset=dataset_name, selection=selection, ptoverM_0=pt_i_overM[:, 0][selection_mask], ptoverM_1=pt_i_overM[:, 1][selection_mask], ptoverM_2=pt_i_overM[:, 2][selection_mask]) output["dR_i_jk"].fill(dataset=dataset_name, selection=selection, dR_0_12=dR_i_jk[:, 0][selection_mask], dR_1_20=dR_i_jk[:, 1][selection_mask], dR_2_01=dR_i_jk[:, 2][selection_mask]) output["dEta_i_jk"].fill(dataset=dataset_name, selection=selection, dEta_0_12=dEta_i_jk[:, 0][selection_mask], dEta_1_20=dEta_i_jk[:, 1][selection_mask], dEta_2_01=dEta_i_jk[:, 2][selection_mask]) output["dPhi_i_jk"].fill(dataset=dataset_name, selection=selection, dPhi_0_12=dPhi_i_jk[:, 0][selection_mask], dPhi_1_20=dPhi_i_jk[:, 1][selection_mask], dPhi_2_01=dPhi_i_jk[:, 2][selection_mask]) output["dPtoverM_i_jk"].fill( dataset=dataset_name, selection=selection, dPtoverM_0_12=dPtoverM_0_12[selection_mask], dPtoverM_1_20=dPtoverM_1_20[selection_mask], dPtoverM_2_01=dPtoverM_2_01[selection_mask]) pt_i_overM_2fill = pt_i_overM[selection_mask] dR_ij_2fill = dR_ij[selection_mask] dEta_ij_2fill = dEta_ij[selection_mask] dR_i_jk_2fill = dR_i_jk[selection_mask] dEta_i_jk_2fill = dEta_i_jk[selection_mask] dPhi_i_jk_2fill = dPhi_i_jk[selection_mask] dPtoverM_0_12_2fill = dPtoverM_0_12[selection_mask] dPtoverM_1_20_2fill = dPtoverM_1_20[selection_mask] dPtoverM_2_01_2fill = dPtoverM_2_01[selection_mask] selected_jets_2fill = selected_jets[selection_mask] max_pt_overM_2fill = awk.max(pt_i_overM_2fill, axis=1) min_pt_overM_2fill = awk.min(pt_i_overM_2fill, axis=1) max_dR_2fill = awk.max(dR_ij_2fill, axis=1) max_dEta_2fill = awk.max(dEta_ij_2fill, axis=1) min_dR_2fill = awk.min(dR_ij_2fill, axis=1) min_dEta_2fill = awk.min(dEta_ij_2fill, axis=1) min_pt_2fill = awk.min(selected_jets_2fill.pt, axis=1) max_eta_2fill = awk.max(abs(selected_jets_2fill.eta), axis=1) max_dR_i_jk_2fill = awk.max(dR_i_jk_2fill, axis=1) min_dR_i_jk_2fill = awk.min(dR_i_jk_2fill, axis=1) max_dEta_i_jk_2fill = awk.max(dEta_i_jk_2fill, axis=1) min_dEta_i_jk_2fill = awk.min(dEta_i_jk_2fill, axis=1) max_dPhi_i_jk_2fill = awk.max(dPhi_i_jk_2fill, axis=1) min_dPhi_i_jk_2fill = awk.min(dPhi_i_jk_2fill, axis=1) max_dPtoverM_i_jk_2fill = [] min_dPtoverM_i_jk_2fill = [] for pair in zip(dPtoverM_0_12_2fill, dPtoverM_1_20_2fill, dPtoverM_2_01_2fill): max_dPtoverM_i_jk_2fill.append(max(pair)) min_dPtoverM_i_jk_2fill.append(min(pair)) max_dPtoverM_i_jk_2fill = np.array(max_dPtoverM_i_jk_2fill) min_dPtoverM_i_jk_2fill = np.array(min_dPtoverM_i_jk_2fill) max_pt_overM_2fill = awk.fill_none(max_pt_overM_2fill, -99) min_pt_overM_2fill = awk.fill_none(min_pt_overM_2fill, -99) max_dR_2fill = awk.fill_none(max_dR_2fill, -99) max_dEta_2fill = awk.fill_none(max_dEta_2fill, -99) min_dR_2fill = awk.fill_none(min_dR_2fill, -99) min_dEta_2fill = awk.fill_none(min_dEta_2fill, -99) min_pt_2fill = awk.fill_none(min_pt_2fill, -99) max_eta_2fill = awk.fill_none(max_eta_2fill, -99) max_dR_i_jk_2fill = awk.fill_none(max_dR_i_jk_2fill, -99) min_dR_i_jk_2fill = awk.fill_none(min_dR_i_jk_2fill, -99) max_dEta_i_jk_2fill = awk.fill_none(max_dEta_i_jk_2fill, -99) min_dEta_i_jk_2fill = awk.fill_none(min_dEta_i_jk_2fill, -99) max_dPhi_i_jk_2fill = awk.fill_none(max_dPhi_i_jk_2fill, -99) min_dPhi_i_jk_2fill = awk.fill_none(min_dPhi_i_jk_2fill, -99) output["max_dR"].fill(dataset=dataset_name, selection=selection, max_dR=max_dR_2fill) output["max_dEta"].fill(dataset=dataset_name, selection=selection, max_dEta=max_dEta_2fill) output["min_dR"].fill(dataset=dataset_name, selection=selection, min_dR=min_dR_2fill) output["min_dEta"].fill(dataset=dataset_name, selection=selection, min_dEta=min_dEta_2fill) output["min_pt"].fill(dataset=dataset_name, selection=selection, min_pt=min_pt_2fill) output["max_eta"].fill(dataset=dataset_name, selection=selection, max_eta=max_eta_2fill) output["max_ptoverM"].fill(dataset=dataset_name, selection=selection, max_ptoverM=max_pt_overM_2fill) output["min_ptoverM"].fill(dataset=dataset_name, selection=selection, min_ptoverM=min_pt_overM_2fill) output["max_dR_j_jj"].fill(dataset=dataset_name, selection=selection, max_dR_j_jj=max_dR_i_jk_2fill) output["max_dEta_j_jj"].fill(dataset=dataset_name, selection=selection, max_dEta_j_jj=max_dEta_i_jk_2fill) output["max_dPhi_j_jj"].fill(dataset=dataset_name, selection=selection, max_dPhi_j_jj=max_dPhi_i_jk_2fill) output["max_dPtoverM_j_jj"].fill( dataset=dataset_name, selection=selection, max_dPtoverM_j_jj=max_dPtoverM_i_jk_2fill) output["min_dR_j_jj"].fill(dataset=dataset_name, selection=selection, min_dR_j_jj=min_dR_i_jk_2fill) output["min_dEta_j_jj"].fill(dataset=dataset_name, selection=selection, min_dEta_j_jj=min_dEta_i_jk_2fill) output["min_dPhi_j_jj"].fill(dataset=dataset_name, selection=selection, min_dPhi_j_jj=min_dPhi_i_jk_2fill) output["min_dPtoverM_j_jj"].fill( dataset=dataset_name, selection=selection, min_dPtoverM_j_jj=min_dPtoverM_i_jk_2fill) return output
def dilep_baseline(self, omit=[], cutflow=None, tight=False, SS=True): ''' give it a cutflow object if you want it to be filed. cuts in the omit list will not be applied ''' self.selection = PackedSelection() is_dilep = ((ak.num(self.ele) + ak.num(self.mu))==2) pos_charge = ((ak.sum(self.ele.pdgId, axis=1) + ak.sum(self.mu.pdgId, axis=1))<0) neg_charge = ((ak.sum(self.ele.pdgId, axis=1) + ak.sum(self.mu.pdgId, axis=1))>0) lep0pt = ((ak.num(self.ele[(self.ele.pt>25)]) + ak.num(self.mu[(self.mu.pt>25)]))>0) lep1pt = ((ak.num(self.ele[(self.ele.pt>20)]) + ak.num(self.mu[(self.mu.pt>20)]))>1) lepveto = ((ak.num(self.ele_veto) + ak.num(self.mu_veto))==2) dimu = choose(self.mu, 2) diele = choose(self.ele, 2) dilep = cross(self.mu, self.ele) if SS: is_SS = ( ak.any((dimu['0'].charge * dimu['1'].charge)>0, axis=1) | \ ak.any((diele['0'].charge * diele['1'].charge)>0, axis=1) | \ ak.any((dilep['0'].charge * dilep['1'].charge)>0, axis=1) ) else: is_OS = ( ak.any((dimu['0'].charge * dimu['1'].charge)<0, axis=1) | \ ak.any((diele['0'].charge * diele['1'].charge)<0, axis=1) | \ ak.any((dilep['0'].charge * dilep['1'].charge)<0, axis=1) ) lepton = ak.concatenate([self.ele, self.mu], axis=1) lepton_pdgId_pt_ordered = ak.fill_none( ak.pad_none( lepton[ak.argsort(lepton.pt, ascending=False)].pdgId, 2, clip=True), 0) triggers = getTriggers(self.events, ak.flatten(lepton_pdgId_pt_ordered[:,0:1]), ak.flatten(lepton_pdgId_pt_ordered[:,1:2]), year=self.year, dataset=self.dataset) ht = ak.sum(self.jet_all.pt, axis=1) st = self.met.pt + ht + ak.sum(self.mu.pt, axis=1) + ak.sum(self.ele.pt, axis=1) self.selection.add('lepveto', lepveto) self.selection.add('dilep', is_dilep) #self.selection.add('filter', self.filters) self.selection.add('trigger', triggers) self.selection.add('p_T(lep0)>25', lep0pt) self.selection.add('p_T(lep1)>20', lep1pt) if SS: self.selection.add('SS', is_SS ) else: self.selection.add('OS', is_OS ) self.selection.add('N_jet>3', (ak.num(self.jet_all)>3) ) self.selection.add('N_jet>4', (ak.num(self.jet_all)>4) ) self.selection.add('N_central>2', (ak.num(self.jet_central)>2) ) self.selection.add('N_central>3', (ak.num(self.jet_central)>3) ) self.selection.add('N_btag>0', (ak.num(self.jet_btag)>0) ) self.selection.add('N_fwd>0', (ak.num(self.jet_fwd)>0) ) self.selection.add('MET>30', (self.met.pt>30) ) self.selection.add('MET>50', (self.met.pt>50) ) self.selection.add('ST>600', (st>600) ) ss_reqs = [ # 'filter', 'lepveto', 'dilep', 'p_T(lep0)>25', 'p_T(lep1)>20', 'trigger', 'SS' if SS else 'OS', 'N_jet>3', 'N_central>2', 'N_btag>0', 'MET>30', 'N_fwd>0', ] if tight: ss_reqs += [ 'N_jet>4', 'N_central>3', 'ST>600', 'MET>50', #'delta_eta', ] ss_reqs_d = { sel: True for sel in ss_reqs if not sel in omit } ss_selection = self.selection.require(**ss_reqs_d) if cutflow: # cutflow_reqs_d = {} for req in ss_reqs: cutflow_reqs_d.update({req: True}) cutflow.addRow( req, self.selection.require(**cutflow_reqs_d) ) return ss_selection
def process(self, events): output = self.accumulator.identity() # use a very loose preselection to filter the events presel = ak.num(events.Jet)>2 ev = events[presel] dataset = ev.metadata['dataset'] # load the config - probably not needed anymore cfg = loadConfig() output['totalEvents']['all'] += len(events) output['skimmedEvents']['all'] += len(ev) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): ## Generated leptons gen_lep = ev.GenL leading_gen_lep = gen_lep[ak.singletons(ak.argmax(gen_lep.pt, axis=1))] trailing_gen_lep = gen_lep[ak.singletons(ak.argmin(gen_lep.pt, axis=1))] ## Muons muon = Collections(ev, "Muon", "tightSSTTH").get() vetomuon = Collections(ev, "Muon", "vetoTTH").get() dimuon = choose(muon, 2) SSmuon = ak.any((dimuon['0'].charge * dimuon['1'].charge)>0, axis=1) leading_muon_idx = ak.singletons(ak.argmax(muon.pt, axis=1)) leading_muon = muon[leading_muon_idx] ## Electrons electron = Collections(ev, "Electron", "tightSSTTH").get() vetoelectron = Collections(ev, "Electron", "vetoTTH").get() dielectron = choose(electron, 2) SSelectron = ak.any((dielectron['0'].charge * dielectron['1'].charge)>0, axis=1) leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1)) leading_electron = electron[leading_electron_idx] ## Merge electrons and muons - this should work better now in ak1 dilepton = cross(muon, electron) SSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge)>0, axis=1) lepton = ak.concatenate([muon, electron], axis=1) leading_lepton_idx = ak.singletons(ak.argmax(lepton.pt, axis=1)) leading_lepton = lepton[leading_lepton_idx] trailing_lepton_idx = ak.singletons(ak.argmin(lepton.pt, axis=1)) trailing_lepton = lepton[trailing_lepton_idx] dilepton_mass = (leading_lepton+trailing_lepton).mass dilepton_pt = (leading_lepton+trailing_lepton).pt dilepton_dR = delta_r(leading_lepton, trailing_lepton) lepton_pdgId_pt_ordered = ak.fill_none(ak.pad_none(lepton[ak.argsort(lepton.pt, ascending=False)].pdgId, 2, clip=True), 0) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): n_nonprompt = getNonPromptFromFlavour(electron) + getNonPromptFromFlavour(muon) n_chargeflip = getChargeFlips(electron, ev.GenPart) + getChargeFlips(muon, ev.GenPart) mt_lep_met = mt(lepton.pt, lepton.phi, ev.MET.pt, ev.MET.phi) min_mt_lep_met = ak.min(mt_lep_met, axis=1) ## Tau and other stuff tau = getTaus(ev) track = getIsoTracks(ev) ## Jets jet = getJets(ev, minPt=25, maxEta=4.7, pt_var='pt_nom') jet = jet[ak.argsort(jet.pt_nom, ascending=False)] # need to sort wrt smeared and recorrected jet pt jet = jet[~match(jet, muon, deltaRCut=0.4)] # remove jets that overlap with muons jet = jet[~match(jet, electron, deltaRCut=0.4)] # remove jets that overlap with electrons central = jet[(abs(jet.eta)<2.4)] btag = getBTagsDeepFlavB(jet, year=self.year) # should study working point for DeepJet light = getBTagsDeepFlavB(jet, year=self.year, invert=True) fwd = getFwdJet(light) fwd_noPU = getFwdJet(light, puId=False) high_score_btag = central[ak.argsort(central.btagDeepFlavB)][:,:2] bl = cross(lepton, high_score_btag) bl_dR = delta_r(bl['0'], bl['1']) min_bl_dR = ak.min(bl_dR, axis=1) ## forward jets j_fwd = fwd[ak.singletons(ak.argmax(fwd.p, axis=1))] # highest momentum spectator jf = cross(j_fwd, jet) mjf = (jf['0']+jf['1']).mass j_fwd2 = jf[ak.singletons(ak.argmax(mjf, axis=1))]['1'] # this is the jet that forms the largest invariant mass with j_fwd delta_eta = abs(j_fwd2.eta - j_fwd.eta) ## MET -> can switch to puppi MET met_pt = ev.MET.pt met_phi = ev.MET.phi ## other variables ht = ak.sum(jet.pt, axis=1) st = met_pt + ht + ak.sum(muon.pt, axis=1) + ak.sum(electron.pt, axis=1) # define the weight weight = Weights( len(ev) ) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): # lumi weight weight.add("weight", ev.weight*cfg['lumi'][self.year]) #weight.add("weight", ev.genWeight*cfg['lumi'][self.year]*mult) # PU weight - not in the babies... weight.add("PU", ev.puWeight, weightUp=ev.puWeightUp, weightDown=ev.puWeightDown, shift=False) # b-tag SFs weight.add("btag", self.btagSF.Method1a(btag, light)) # lepton SFs weight.add("lepton", self.leptonSF.get(electron, muon)) cutflow = Cutflow(output, ev, weight=weight) sel = Selection( dataset = dataset, events = ev, year = self.year, ele = electron, ele_veto = vetoelectron, mu = muon, mu_veto = vetomuon, jet_all = jet, jet_central = central, jet_btag = btag, jet_fwd = fwd, met = ev.MET, ) BL = sel.dilep_baseline(cutflow=cutflow, SS=True) weight_BL = weight.weight()[BL] if True: # define the inputs to the NN # this is super stupid. there must be a better way. NN_inputs = np.stack([ ak.to_numpy(ak.num(jet[BL])), ak.to_numpy(ak.num(tau[BL])), ak.to_numpy(ak.num(track[BL])), ak.to_numpy(st[BL]), ak.to_numpy(ev.MET[BL].pt), ak.to_numpy(ak.max(mjf[BL], axis=1)), ak.to_numpy(pad_and_flatten(delta_eta[BL])), ak.to_numpy(pad_and_flatten(leading_lepton[BL].pt)), ak.to_numpy(pad_and_flatten(leading_lepton[BL].eta)), ak.to_numpy(pad_and_flatten(trailing_lepton[BL].pt)), ak.to_numpy(pad_and_flatten(trailing_lepton[BL].eta)), ak.to_numpy(pad_and_flatten(dilepton_mass[BL])), ak.to_numpy(pad_and_flatten(dilepton_pt[BL])), ak.to_numpy(pad_and_flatten(j_fwd[BL].pt)), ak.to_numpy(pad_and_flatten(j_fwd[BL].p)), ak.to_numpy(pad_and_flatten(j_fwd[BL].eta)), ak.to_numpy(pad_and_flatten(jet[:, 0:1][BL].pt)), ak.to_numpy(pad_and_flatten(jet[:, 1:2][BL].pt)), ak.to_numpy(pad_and_flatten(jet[:, 0:1][BL].eta)), ak.to_numpy(pad_and_flatten(jet[:, 1:2][BL].eta)), ak.to_numpy(pad_and_flatten(high_score_btag[:, 0:1][BL].pt)), ak.to_numpy(pad_and_flatten(high_score_btag[:, 1:2][BL].pt)), ak.to_numpy(pad_and_flatten(high_score_btag[:, 0:1][BL].eta)), ak.to_numpy(pad_and_flatten(high_score_btag[:, 1:2][BL].eta)), ak.to_numpy(min_bl_dR[BL]), ak.to_numpy(min_mt_lep_met[BL]), ]) NN_inputs = np.moveaxis(NN_inputs, 0, 1) model, scaler = load_onnx_model('v8') try: NN_inputs_scaled = scaler.transform(NN_inputs) NN_pred = predict_onnx(model, NN_inputs_scaled) best_score = np.argmax(NN_pred, axis=1) except ValueError: #print ("Empty NN_inputs") NN_pred = np.array([]) best_score = np.array([]) NN_inputs_scaled = NN_inputs #k.clear_session() output['node'].fill(dataset=dataset, multiplicity=best_score, weight=weight_BL) output['node0_score_incl'].fill(dataset=dataset, score=NN_pred[:,0] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL) output['node0_score'].fill(dataset=dataset, score=NN_pred[best_score==0][:,0] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==0]) output['node1_score'].fill(dataset=dataset, score=NN_pred[best_score==1][:,1] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==1]) output['node2_score'].fill(dataset=dataset, score=NN_pred[best_score==2][:,2] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==2]) output['node3_score'].fill(dataset=dataset, score=NN_pred[best_score==3][:,3] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==3]) output['node4_score'].fill(dataset=dataset, score=NN_pred[best_score==4][:,4] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==4]) SR_sel_pp = ((best_score==0) & ak.flatten((leading_lepton[BL].pdgId<0))) SR_sel_mm = ((best_score==0) & ak.flatten((leading_lepton[BL].pdgId>0))) leading_lepton_BL = leading_lepton[BL] output['lead_lep_SR_pp'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_lepton_BL[SR_sel_pp].pt)), weight = weight_BL[SR_sel_pp] ) output['lead_lep_SR_mm'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_lepton_BL[SR_sel_mm].pt)), weight = weight_BL[SR_sel_mm] ) del model del scaler del NN_inputs, NN_inputs_scaled, NN_pred # first, make a few super inclusive plots output['PV_npvs'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvs, weight=weight_BL) output['PV_npvsGood'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvsGood, weight=weight_BL) output['N_jet'].fill(dataset=dataset, multiplicity=ak.num(jet)[BL], weight=weight_BL) output['N_b'].fill(dataset=dataset, multiplicity=ak.num(btag)[BL], weight=weight_BL) output['N_central'].fill(dataset=dataset, multiplicity=ak.num(central)[BL], weight=weight_BL) output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(electron)[BL], weight=weight_BL) output['N_mu'].fill(dataset=dataset, multiplicity=ak.num(electron)[BL], weight=weight_BL) output['N_fwd'].fill(dataset=dataset, multiplicity=ak.num(fwd)[BL], weight=weight_BL) output['ST'].fill(dataset=dataset, pt=st[BL], weight=weight_BL) output['HT'].fill(dataset=dataset, pt=ht[BL], weight=weight_BL) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): output['nLepFromTop'].fill(dataset=dataset, multiplicity=ev[BL].nLepFromTop, weight=weight_BL) output['nLepFromTau'].fill(dataset=dataset, multiplicity=ev.nLepFromTau[BL], weight=weight_BL) output['nLepFromZ'].fill(dataset=dataset, multiplicity=ev.nLepFromZ[BL], weight=weight_BL) output['nLepFromW'].fill(dataset=dataset, multiplicity=ev.nLepFromW[BL], weight=weight_BL) output['nGenTau'].fill(dataset=dataset, multiplicity=ev.nGenTau[BL], weight=weight_BL) output['nGenL'].fill(dataset=dataset, multiplicity=ak.num(ev.GenL[BL], axis=1), weight=weight_BL) output['chargeFlip_vs_nonprompt'].fill(dataset=dataset, n1=n_chargeflip[BL], n2=n_nonprompt[BL], n_ele=ak.num(electron)[BL], weight=weight_BL) output['MET'].fill( dataset = dataset, pt = ev.MET[BL].pt, phi = ev.MET[BL].phi, weight = weight_BL ) if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset): output['lead_gen_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_gen_lep[BL].pt)), eta = ak.to_numpy(ak.flatten(leading_gen_lep[BL].eta)), phi = ak.to_numpy(ak.flatten(leading_gen_lep[BL].phi)), weight = weight_BL ) output['trail_gen_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].pt)), eta = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].eta)), phi = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].phi)), weight = weight_BL ) output['lead_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(leading_lepton[BL].pt)), eta = ak.to_numpy(ak.flatten(leading_lepton[BL].eta)), phi = ak.to_numpy(ak.flatten(leading_lepton[BL].phi)), weight = weight_BL ) output['trail_lep'].fill( dataset = dataset, pt = ak.to_numpy(ak.flatten(trailing_lepton[BL].pt)), eta = ak.to_numpy(ak.flatten(trailing_lepton[BL].eta)), phi = ak.to_numpy(ak.flatten(trailing_lepton[BL].phi)), weight = weight_BL ) output['j1'].fill( dataset = dataset, pt = ak.flatten(jet.pt_nom[:, 0:1][BL]), eta = ak.flatten(jet.eta[:, 0:1][BL]), phi = ak.flatten(jet.phi[:, 0:1][BL]), weight = weight_BL ) output['j2'].fill( dataset = dataset, pt = ak.flatten(jet[:, 1:2][BL].pt_nom), eta = ak.flatten(jet[:, 1:2][BL].eta), phi = ak.flatten(jet[:, 1:2][BL].phi), weight = weight_BL ) output['j3'].fill( dataset = dataset, pt = ak.flatten(jet[:, 2:3][BL].pt_nom), eta = ak.flatten(jet[:, 2:3][BL].eta), phi = ak.flatten(jet[:, 2:3][BL].phi), weight = weight_BL ) output['fwd_jet'].fill( dataset = dataset, pt = ak.flatten(j_fwd[BL].pt), eta = ak.flatten(j_fwd[BL].eta), phi = ak.flatten(j_fwd[BL].phi), weight = weight_BL ) output['high_p_fwd_p'].fill(dataset=dataset, p = ak.flatten(j_fwd[BL].p), weight = weight_BL) return output
out_events["eleTightSF0"] = evaluator["EGamma_SF2D_T"](out_events.eleeta0, out_events.elept0) out_events["eleLooseSF1"] = evaluator["EGamma_SF2D_L"](out_events.eleeta1, out_events.elept1) out_events["eleTrigSF0"] = evaluator["EGamma_SF2D_Trig"](out_events.eleeta0, out_events.elept0) out_events["eleRecoSF0"] = evaluator["EGamma_SF2D_Reco"](out_events.eleeta0, out_events.elept0) eleRecoSF1_hi = evaluator["EGamma_SF2D_Reco"](out_events.eleeta1, out_events.elept1) eleRecoSF1_lo = evaluator["EGamma_SF2D_Reco_lowpt"](out_events.eleeta1, out_events.elept1) eleRecoSF1_hi_ = ak.fill_none(ak.mask(eleRecoSF1_hi, out_events.elept1 > 20.), 0) eleRecoSF1_lo_ = ak.fill_none(ak.mask(eleRecoSF1_lo, out_events.elept1 > 20.), 0) out_events["eleRecoSF1"] = eleRecoSF1_hi_ + eleRecoSF1_lo_ bcdef_lumi = 19.554725529 gh_lumi = 16.224846377 total_lumi = bcdef_lumi + gh_lumi ##--------low pt Loose muonLooseIDSF_lowpt1 = ( (bcdef_lumi * evaluator["muon_lowpt_BCDEF_LooseID"] (out_events.mupt1, abs(out_events.mueta1))) + (gh_lumi * evaluator["muon_lowpt_GH_LooseID"] (out_events.mupt1, abs(out_events.mueta1)))) / total_lumi