def event_iterator(filename, handles=None):
"""handles is a list of tuples: (varname, type, InputTag)"""
events = Events(filename)
if not handles: handles = []
for evt in events.__iter__():
for name,typ,inputtag in handles:
handle = Handle(typ)
evt.getByLabel(inputtag, handle)
setattr(evt, "hndl_" + name, handle)
yield evt
#! /bin/env python
import ROOT
import pprint
from DataFormats.FWLite import Events, Handle
ROOT.gROOT.SetBatch()
events = Events('/hdfs/store/user/tapas/DoubleMu/Run2012D-16Jan2013-v2/AOD/2013-04-01-8TeV-53X-PatTuple_Master/patTuple_cfg-00A4899E-666B-E211-A2AC-E0CB4E29C50D.root')
evt = events.__iter__().next()
evt.getByLabel(label, handle)
handle = Handle('std::vector<pat::Tau>')
label = "patTriggerEvent"
obj = handle.product()
algo_names = [i.name() for i in obj.paths()]
print filter(lambda x: 'Mu8_Ele17' in x, algo_names)
## handle = Handle('pat::TriggerEvent')
## label = "patTriggerEvent"
## obj = handle.product()
## algo_names = [i.name() for i in obj.paths()]
## print filter(lambda x: 'Mu8_Ele17' in x, algo_names)
import ROOT
import pprint
import sys
from DataFormats.FWLite import Events, Handle
ROOT.gROOT.SetBatch()
events = Events('validate_ctag_pat.root')
jet_labels = [
"selectedPatJets"
] #, "selectedPatJetsAK4PF", "selectedPatJetsAK8PFCHSSoftDropSubjets"]
tested_discriminators = ['pfCombinedCvsLJetTags', 'pfCombinedCvsBJetTags']
evt = next(events.__iter__())
handle = Handle('std::vector<pat::Jet>')
for label in jet_labels:
evt.getByLabel(label, handle)
jets = handle.product()
jet = jets.at(0)
available = set([i.first for i in jet.getPairDiscri()])
for test in tested_discriminators:
print "%s in %s: %s" % (test, label, test in available)
import ROOT
import pprint
import sys
from DataFormats.FWLite import Events, Handle
ROOT.gROOT.SetBatch()
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('file')
parser.add_argument('collections', default=['slimmedJets'], nargs='*')
args = parser.parse_args()
events = Events(args.file)
jet_labels = args.collections
tested_discriminators = ['pfCombinedCvsLJetTags', 'pfCombinedCvsBJetTags']
evt = next(events.__iter__())
handle = Handle('std::vector<pat::Jet>')
for label in jet_labels:
evt.getByLabel(label, handle)
jets = handle.product()
jet = jets.at(0)
available = set([i.first for i in jet.getPairDiscri()])
for test in tested_discriminators:
print "%s in %s: %s" % (test, label, test in available)
class TBFileReader:
def __init__(self, filename, **optional):
if not os.path.exists(filename):
sys.exit("** file not found: %s" % filename)
# cache input variables
self.filename = filename
# create options by scanning file
print "reading file %s ..." % filename
os.system("edmDumpEventContent %s >& .dumpevent" % filename)
records = open(".dumpevent").readlines()
for ii, record in enumerate(records):
if record[:4] != "----": continue
records = records[ii + 1:]
break
objects = {}
for ii, record in enumerate(records):
record = simplify.sub(">", strip(record))
t = split(record)
s = extract.findall(record)
if len(s) > 0:
name = s[0]
else:
name = t[0]
objects[name] = (t[0], dequote.sub("",
t[1]), dequote.sub("", t[2]))
# create event buffer, get event iterator,
# and create handles
self.events = Events(filename)
self.iter = self.events.__iter__()
self.event = self.iter.next()
self.numberOfEvents = self.event.size()
print "\n Number of events: %d" % self.numberOfEvents
self.handles = {}
print " %-20s %s" % ("Key", "Type")
print "-" * 78
keys = objects.keys()
keys.sort()
for key in keys:
edmtype, label1, label2 = objects[key]
h = Handle(edmtype)
self.handles[key] = h
print " %-20s %s" % (key, edmtype)
self.entry = 0
self.buffer = {}
self.objects = objects
self.keys = keys
def __del__(self):
pass
# read event at specified index in TFile and
# cache requested objects
def read(self, index):
if index < 0: return False
if index > self.numberOfEvents - 1: return False
self.event.to(index)
for key in self.keys:
handle = self.handles[key]
if handle == None: continue
edmtype, module, label = self.objects[key]
self.event.getByLabel(module, label, handle)
self.buffer[key] = handle.product()
self.entry += 1
return True
# get next event and cache requested objects
def next(self):
try:
self.event = self.iter.next()
except StopIteration:
return False
for key in self.keys:
handle = self.handles[key]
if handle == None: continue
edmtype, module, label = self.objects[key]
self.event.getByLabel(module, label, handle)
self.buffer[key] = handle.product()
self.entry += 1
return True
# return object by key
def __call__(self, key):
try:
return self.buffer[key]
except:
return None
def entries(self):
return self.numberOfEvents
def names(self):
return self.keys()
def __len__(self):
return self.entries()
class METProducerTest(unittest.TestCase):
def setUp(self):
self.exEvents = Events([options.expectedPath])
self.acEvents = Events([options.actualPath])
self.exHandleGenMETs = Handle("std::vector<reco::GenMET>")
self.exHandlePFMETs = Handle("std::vector<reco::PFMET>")
self.exHandleCaloMETs = Handle("std::vector<reco::CaloMET>")
self.exHandleMETs = Handle("std::vector<reco::MET>")
self.exHandlePFClusterMETs = Handle("std::vector<reco::PFClusterMET>")
self.acHandleGenMETs = Handle("std::vector<reco::GenMET>")
self.acHandlePFMETs = Handle("std::vector<reco::PFMET>")
self.acHandleCaloMETs = Handle("std::vector<reco::CaloMET>")
self.acHandleMETs = Handle("std::vector<reco::MET>")
self.acHandlePFClusterMETs = Handle("std::vector<reco::PFClusterMET>")
def test_n_events(self):
self.assertEqual(self.exEvents.size(), self.acEvents.size())
def test_recoPFMETs_pfMetT0rt(self):
label = ("pfMetT0rt", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT1(self):
label = ("pfMetT0rtT1", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT1T2(self):
label = ("pfMetT0rtT1T2", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT2(self):
label = ("pfMetT0rtT2", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0pc(self):
label = ("pfMetT0pc", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0pcT1(self):
label = ("pfMetT0pcT1", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT1(self):
label = ("pfMetT1", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT1T2(self):
label = ("pfMetT1T2", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtTxy(self):
label = ("pfMetT0rtTxy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT1Txy(self):
label = ("pfMetT0rtT1Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT1T2Txy(self):
label = ("pfMetT0rtT1T2Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT2Txy(self):
label = ("pfMetT0rtT2Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0pcTxy(self):
label = ("pfMetT0pcTxy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT0pcT1Txy(self):
label = ("pfMetT0pcT1Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT1Txy(self):
label = ("pfMetT1Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfMetT1T2Txy(self):
label = ("pfMetT1T2Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_caloMetT1(self):
label = ("caloMetT1", "","TEST")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_caloMetT1T2(self):
label = ("caloMetT1T2", "","TEST")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def assert_collection(self, label, exHandle, acHandle, candidateAssertMethods):
exEventIter = self.exEvents.__iter__()
acEventIter = self.acEvents.__iter__()
nevents = min(self.exEvents.size(), self.acEvents.size())
for i in range(nevents):
exEvent = exEventIter.next()
acEvent = acEventIter.next()
exEvent.getByLabel(label, exHandle)
exMETs = exHandle.product()
exMET = exMETs.front()
acEvent.getByLabel(label, acHandle)
acMETs = acHandle.product()
self.assertEqual(acMETs.size(), 1)
acMET = acMETs.front()
for method in candidateAssertMethods:
getattr(self, method)(acMET, exMET)
def assert_recoPFMET(self, actual, expected):
# double
self.assertEqual(actual.photonEtFraction() , expected.photonEtFraction() )
self.assertAlmostEqual(actual.photonEt() , expected.photonEt() , 12 )
self.assertEqual(actual.neutralHadronEtFraction() , expected.neutralHadronEtFraction() )
self.assertAlmostEqual(actual.neutralHadronEt() , expected.neutralHadronEt() , 12 )
self.assertEqual(actual.electronEtFraction() , expected.electronEtFraction() )
self.assertAlmostEqual(actual.electronEt() , expected.electronEt() , 12 )
self.assertEqual(actual.chargedHadronEtFraction() , expected.chargedHadronEtFraction() )
self.assertAlmostEqual(actual.chargedHadronEt() , expected.chargedHadronEt() , 12 )
self.assertEqual(actual.muonEtFraction() , expected.muonEtFraction() )
self.assertAlmostEqual(actual.muonEt() , expected.muonEt() , 12 )
self.assertEqual(actual.HFHadronEtFraction() , expected.HFHadronEtFraction() )
self.assertAlmostEqual(actual.HFHadronEt() , expected.HFHadronEt() , 12 )
self.assertEqual(actual.HFEMEtFraction() , expected.HFEMEtFraction() )
self.assertAlmostEqual(actual.HFEMEt() , expected.HFEMEt() , 12 )
def assert_recoGenMET(self, actual, expected):
# double
self.assertEqual(actual.NeutralEMEtFraction() , expected.NeutralEMEtFraction() )
self.assertEqual(actual.NeutralEMEt() , expected.NeutralEMEt() )
self.assertEqual(actual.ChargedEMEtFraction() , expected.ChargedEMEtFraction() )
self.assertEqual(actual.ChargedEMEt() , expected.ChargedEMEt() )
self.assertEqual(actual.NeutralHadEtFraction() , expected.NeutralHadEtFraction() )
self.assertEqual(actual.NeutralHadEt() , expected.NeutralHadEt() )
self.assertEqual(actual.ChargedHadEtFraction() , expected.ChargedHadEtFraction() )
self.assertEqual(actual.ChargedHadEt() , expected.ChargedHadEt() )
self.assertEqual(actual.MuonEtFraction() , expected.MuonEtFraction() )
self.assertEqual(actual.MuonEt() , expected.MuonEt() )
self.assertEqual(actual.InvisibleEtFraction() , expected.InvisibleEtFraction() )
self.assertEqual(actual.InvisibleEt() , expected.InvisibleEt() )
def assert_recoCaloMET(self, actual, expected):
# double
self.assertEqual(actual.maxEtInEmTowers() , expected.maxEtInEmTowers() )
self.assertEqual(actual.maxEtInHadTowers() , expected.maxEtInHadTowers() )
self.assertAlmostEqual(actual.etFractionHadronic() , expected.etFractionHadronic(), 15 )
self.assertAlmostEqual(actual.emEtFraction() , expected.emEtFraction() , 15 )
self.assertEqual(actual.hadEtInHB() , expected.hadEtInHB() )
self.assertEqual(actual.hadEtInHO() , expected.hadEtInHO() )
self.assertEqual(actual.hadEtInHE() , expected.hadEtInHE() )
self.assertEqual(actual.hadEtInHF() , expected.hadEtInHF() )
self.assertEqual(actual.emEtInEB() , expected.emEtInEB() )
self.assertEqual(actual.emEtInEE() , expected.emEtInEE() )
self.assertEqual(actual.emEtInHF() , expected.emEtInHF() )
self.assertEqual(actual.metSignificance() , expected.metSignificance() )
self.assertEqual(actual.CaloSETInpHF() , expected.CaloSETInpHF() )
self.assertEqual(actual.CaloSETInmHF() , expected.CaloSETInmHF() )
self.assertEqual(actual.CaloMETInpHF() , expected.CaloMETInpHF() )
self.assertEqual(actual.CaloMETInmHF() , expected.CaloMETInmHF() )
self.assertEqual(actual.CaloMETPhiInpHF() , expected.CaloMETPhiInpHF() )
self.assertEqual(actual.CaloMETPhiInmHF() , expected.CaloMETPhiInmHF() )
def assert_recoMET(self, actual, expected):
# double
self.assertAlmostEqual(actual.sumEt() , expected.sumEt() , 12)
self.assertAlmostEqual(actual.mEtSig() , expected.mEtSig() , 12)
self.assertEqual(actual.significance() , expected.significance() )
self.assertEqual(actual.e_longitudinal() , expected.e_longitudinal() )
self.assertEqual(actual.dmEx().size() , expected.dmEx().size())
for a, e in zip(actual.dmEx(), expected.dmEx()):
self.assertEqual(a , e)
self.assertEqual(actual.dmEy().size() , expected.dmEy().size())
for a, e in zip(actual.dmEy(), expected.dmEy()):
self.assertEqual(a , e)
self.assertEqual(actual.dsumEt().size() , expected.dsumEt().size())
for a, e in zip(actual.dsumEt(), expected.dsumEt()):
self.assertEqual(a , e)
self.assertEqual(actual.dSignificance().size() , expected.dSignificance().size())
for a, e in zip(actual.dSignificance(), expected.dSignificance()):
self.assertEqual(a , e)
self.assertEqual(actual.mEtCorr().size(), expected.mEtCorr().size())
for a, e in zip(actual.mEtCorr(), expected.mEtCorr()):
# self.assertEqual(a.mex , e.mex)
# self.assertEqual(a.mey , e.mey)
# self.assertAlmostEqual(a.sumet , e.sumet, 4)
# self.assertEqual(a.significance , e.significance)
pass
def assert_recoLeafCandidate(self, actual, expected):
# size_t
self.assertEqual(actual.numberOfDaughters() , expected.numberOfDaughters() )
self.assertEqual(actual.numberOfMothers() , expected.numberOfMothers() )
# int
self.assertEqual(actual.charge() , expected.charge() )
self.assertEqual(actual.threeCharge() , expected.threeCharge() )
# double
self.assertEqual(actual.p() , expected.p() )
self.assertAlmostEqual(actual.energy() , expected.energy() , 10 )
self.assertAlmostEqual(actual.et() , expected.et() , 10 )
# self.assertEqual(actual.mass() , expected.mass() )
# self.assertEqual(actual.massSqr() , expected.massSqr() )
self.assertAlmostEqual(actual.mt() , expected.mt() , 10 )
self.assertAlmostEqual(actual.mtSqr() , expected.mtSqr() , 10 )
self.assertEqual(actual.px() , expected.px() )
self.assertEqual(actual.py() , expected.py() )
self.assertEqual(actual.pz() , expected.pz() )
self.assertAlmostEqual(actual.pt(), expected.pt(), 5)
self.assertEqual(actual.phi() , expected.phi() )
self.assertEqual(actual.theta() , expected.theta() )
self.assertEqual(actual.eta() , expected.eta() )
# self.assertEqual(actual.rapidity() , expected.rapidity() )
# self.assertEqual(actual.y() , expected.y() )
self.assertEqual(actual.vx() , expected.vx() )
self.assertEqual(actual.vy() , expected.vy() )
self.assertEqual(actual.vz() , expected.vz() )
# int
self.assertEqual(actual.pdgId() , expected.pdgId() )
self.assertEqual(actual.status() , expected.status() )
# bool
self.assertEqual(actual.longLived() , expected.longLived() )
self.assertEqual(actual.massConstraint() , expected.massConstraint() )
# double
self.assertEqual(actual.vertexChi2() , expected.vertexChi2() )
self.assertEqual(actual.vertexNdof() , expected.vertexNdof() )
self.assertEqual(actual.vertexNormalizedChi2() , expected.vertexNormalizedChi2() )
# bool
self.assertEqual(actual.hasMasterClone() , expected.hasMasterClone() )
self.assertEqual(actual.hasMasterClonePtr() , expected.hasMasterClonePtr() )
self.assertEqual(actual.isElectron() , expected.isElectron() )
self.assertEqual(actual.isMuon() , expected.isMuon() )
self.assertEqual(actual.isStandAloneMuon() , expected.isStandAloneMuon() )
self.assertEqual(actual.isGlobalMuon() , expected.isGlobalMuon() )
self.assertEqual(actual.isTrackerMuon() , expected.isTrackerMuon() )
self.assertEqual(actual.isCaloMuon() , expected.isCaloMuon() )
self.assertEqual(actual.isPhoton() , expected.isPhoton() )
self.assertEqual(actual.isConvertedPhoton() , expected.isConvertedPhoton() )
self.assertEqual(actual.isJet() , expected.isJet() )
class METProducerTest(unittest.TestCase):
def setUp(self):
self.exEvents = Events([options.expectedPath])
self.acEvents = Events([options.actualPath])
self.exHandleGenMETs = Handle("std::vector<reco::GenMET>")
self.exHandlePFMETs = Handle("std::vector<reco::PFMET>")
self.exHandleCaloMETs = Handle("std::vector<reco::CaloMET>")
self.exHandleMETs = Handle("std::vector<reco::MET>")
self.exHandlePFClusterMETs = Handle("std::vector<reco::PFClusterMET>")
self.acHandleGenMETs = Handle("std::vector<reco::GenMET>")
self.acHandlePFMETs = Handle("std::vector<reco::PFMET>")
self.acHandleCaloMETs = Handle("std::vector<reco::CaloMET>")
self.acHandleMETs = Handle("std::vector<reco::MET>")
self.acHandlePFClusterMETs = Handle("std::vector<reco::PFClusterMET>")
def test_n_events(self):
self.assertEqual(self.exEvents.size(), self.acEvents.size())
def test_recoPFMETs_pfMet(self):
label = ("pfMet" ,"" ,"METP")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoGenMETs_genMetTrue(self):
label = ("genMetTrue" ,"" ,"METP")
exHandle = self.exHandleGenMETs
acHandle = self.acHandleGenMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoGenMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoGenMETs_genMetCalo(self):
label = ("genMetCalo" ,"" ,"METP")
exHandle = self.exHandleGenMETs
acHandle = self.acHandleGenMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoGenMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoGenMETs_genMetCaloAndNonPrompt(self):
label = ("genMetCaloAndNonPrompt" ,"" ,"METP")
exHandle = self.exHandleGenMETs
acHandle = self.acHandleGenMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoGenMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_genMetIC5GenJets(self):
label = ("genMetIC5GenJets", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_tcMet(self):
label = ("tcMet", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_tcMetCST(self):
label = ("tcMetCST", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_tcMetRft2(self):
label = ("tcMetRft2", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_tcMetVedu(self):
label = ("tcMetVedu", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_tcMetWithPFclusters(self):
label = ("tcMetWithPFclusters", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_htMetAK5(self):
label = ("htMetAK5", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
# def test_recoMETs_htMetAK7(self):
# label = ("htMetAK7", "", "METP")
# exHandle = self.exHandleMETs
# acHandle = self.acHandleMETs
# candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
# self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
# def test_recoMETs_htMetKT4(self):
# label = ("htMetKT4", "", "METP")
# exHandle = self.exHandleMETs
# acHandle = self.acHandleMETs
# candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
# self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_htMetKT6(self):
label = ("htMetKT6", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
# def test_recoMETs_htMetIC5(self):
# label = ("htMetIC5", "", "METP")
# exHandle = self.exHandleMETs
# acHandle = self.acHandleMETs
# candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
# self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_met(self):
label = ("met", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_metHO(self):
label = ("metHO", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_metNoHF(self):
label = ("metNoHF", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_metNoHFHO(self):
label = ("metNoHFHO", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_metOpt(self):
label = ("metOpt", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_metOptHO(self):
label = ("metOptHO", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_metOptNoHF(self):
label = ("metOptNoHF", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_metOptNoHFHO(self):
label = ("metOptNoHFHO", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_corMetGlobalMuons(self):
label = ("corMetGlobalMuons", "" ,"METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFClusterMETs_pfClusterMet(self):
label = ("pfClusterMet", "", "METP")
exHandle = self.exHandlePFClusterMETs
acHandle = self.acHandlePFClusterMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoPFMETs_pfChargedMET(self):
label = ("pfChargedMET" ,"" ,"METP")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET', 'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def assert_collection(self, label, exHandle, acHandle, candidateAssertMethods):
exEventIter = self.exEvents.__iter__()
acEventIter = self.acEvents.__iter__()
nevents = min(self.exEvents.size(), self.acEvents.size())
for i in range(nevents):
exEvent = exEventIter.next()
acEvent = acEventIter.next()
exEvent.getByLabel(label, exHandle)
exMETs = exHandle.product()
exMET = exMETs.front()
acEvent.getByLabel(label, acHandle)
acMETs = acHandle.product()
self.assertEqual(acMETs.size(), 1)
acMET = acMETs.front()
for method in candidateAssertMethods:
getattr(self, method)(acMET, exMET)
def assert_recoPFMET(self, actual, expected):
# double
self.assertEqual(actual.photonEtFraction() , expected.photonEtFraction() )
self.assertAlmostEqual(actual.photonEt() , expected.photonEt() , 10)
self.assertEqual(actual.neutralHadronEtFraction() , expected.neutralHadronEtFraction() )
self.assertAlmostEqual(actual.neutralHadronEt() , expected.neutralHadronEt() , 10)
self.assertEqual(actual.electronEtFraction() , expected.electronEtFraction() )
self.assertAlmostEqual(actual.electronEt() , expected.electronEt() , 10)
self.assertEqual(actual.chargedHadronEtFraction() , expected.chargedHadronEtFraction() )
self.assertAlmostEqual(actual.chargedHadronEt() , expected.chargedHadronEt() , 10)
self.assertEqual(actual.muonEtFraction() , expected.muonEtFraction() )
self.assertAlmostEqual(actual.muonEt() , expected.muonEt() , 10)
self.assertEqual(actual.HFHadronEtFraction() , expected.HFHadronEtFraction() )
self.assertAlmostEqual(actual.HFHadronEt() , expected.HFHadronEt() , 10)
self.assertEqual(actual.HFEMEtFraction() , expected.HFEMEtFraction() )
self.assertAlmostEqual(actual.HFEMEt() , expected.HFEMEt() , 10)
def assert_recoGenMET(self, actual, expected):
# double
self.assertEqual(actual.NeutralEMEtFraction() , expected.NeutralEMEtFraction() )
self.assertEqual(actual.NeutralEMEt() , expected.NeutralEMEt() )
self.assertEqual(actual.ChargedEMEtFraction() , expected.ChargedEMEtFraction() )
self.assertEqual(actual.ChargedEMEt() , expected.ChargedEMEt() )
self.assertEqual(actual.NeutralHadEtFraction() , expected.NeutralHadEtFraction() )
self.assertEqual(actual.NeutralHadEt() , expected.NeutralHadEt() )
self.assertEqual(actual.ChargedHadEtFraction() , expected.ChargedHadEtFraction() )
self.assertEqual(actual.ChargedHadEt() , expected.ChargedHadEt() )
self.assertEqual(actual.MuonEtFraction() , expected.MuonEtFraction() )
self.assertEqual(actual.MuonEt() , expected.MuonEt() )
self.assertEqual(actual.InvisibleEtFraction() , expected.InvisibleEtFraction() )
self.assertEqual(actual.InvisibleEt() , expected.InvisibleEt() )
def assert_recoCaloMET(self, actual, expected):
# double
self.assertEqual(actual.maxEtInEmTowers() , expected.maxEtInEmTowers() )
self.assertEqual(actual.maxEtInHadTowers() , expected.maxEtInHadTowers() )
self.assertAlmostEqual(actual.etFractionHadronic() , expected.etFractionHadronic(), 15 )
self.assertAlmostEqual(actual.emEtFraction() , expected.emEtFraction() , 15 )
self.assertEqual(actual.hadEtInHB() , expected.hadEtInHB() )
self.assertEqual(actual.hadEtInHO() , expected.hadEtInHO() )
self.assertEqual(actual.hadEtInHE() , expected.hadEtInHE() )
self.assertEqual(actual.hadEtInHF() , expected.hadEtInHF() )
self.assertEqual(actual.emEtInEB() , expected.emEtInEB() )
self.assertEqual(actual.emEtInEE() , expected.emEtInEE() )
self.assertEqual(actual.emEtInHF() , expected.emEtInHF() )
self.assertEqual(actual.metSignificance() , expected.metSignificance() )
self.assertEqual(actual.CaloSETInpHF() , expected.CaloSETInpHF() )
self.assertEqual(actual.CaloSETInmHF() , expected.CaloSETInmHF() )
self.assertEqual(actual.CaloMETInpHF() , expected.CaloMETInpHF() )
self.assertEqual(actual.CaloMETInmHF() , expected.CaloMETInmHF() )
self.assertEqual(actual.CaloMETPhiInpHF() , expected.CaloMETPhiInpHF() )
self.assertEqual(actual.CaloMETPhiInmHF() , expected.CaloMETPhiInmHF() )
def assert_recoMET(self, actual, expected):
# double
self.assertAlmostEqual(actual.sumEt() , expected.sumEt() , 10)
self.assertAlmostEqual(actual.mEtSig() , expected.mEtSig() , 10)
self.assertEqual(actual.significance() , expected.significance() )
self.assertEqual(actual.e_longitudinal() , expected.e_longitudinal() )
self.assertEqual(actual.dmEx().size() , expected.dmEx().size())
for a, e in zip(actual.dmEx(), expected.dmEx()):
self.assertEqual(a , e)
self.assertEqual(actual.dmEy().size() , expected.dmEy().size())
for a, e in zip(actual.dmEy(), expected.dmEy()):
self.assertEqual(a , e)
self.assertEqual(actual.dsumEt().size() , expected.dsumEt().size())
for a, e in zip(actual.dsumEt(), expected.dsumEt()):
self.assertEqual(a , e)
self.assertEqual(actual.dSignificance().size() , expected.dSignificance().size())
for a, e in zip(actual.dSignificance(), expected.dSignificance()):
self.assertEqual(a , e)
self.assertEqual(actual.mEtCorr().size(), expected.mEtCorr().size())
for a, e in zip(actual.mEtCorr(), expected.mEtCorr()):
# self.assertEqual(a.mex , e.mex)
# self.assertEqual(a.mey , e.mey)
# self.assertEqual(a.sumet , e.sumet)
# self.assertEqual(a.significance , e.significance)
pass
actualSigMatrix = actual.getSignificanceMatrix()
expectedSigMatrix = expected.getSignificanceMatrix()
self.assertEqual(actualSigMatrix.GetNrows(), expectedSigMatrix.GetNrows())
self.assertEqual(actualSigMatrix.GetNcols(), expectedSigMatrix.GetNcols())
self.assertEqual(actualSigMatrix.GetNoElements(), expectedSigMatrix.GetNoElements())
for irow in range(actualSigMatrix.GetNrows()):
for icol in range(actualSigMatrix.GetNcols()):
self.assertEqual(actualSigMatrix(irow, icol), expectedSigMatrix(irow, icol))
def assert_recoLeafCandidate(self, actual, expected):
# size_t
self.assertEqual(actual.numberOfDaughters() , expected.numberOfDaughters() )
self.assertEqual(actual.numberOfMothers() , expected.numberOfMothers() )
# int
self.assertEqual(actual.charge() , expected.charge() )
self.assertEqual(actual.threeCharge() , expected.threeCharge() )
# double
self.assertEqual(actual.p() , expected.p() )
self.assertEqual(actual.energy() , expected.energy() )
self.assertEqual(actual.et() , expected.et() )
self.assertEqual(actual.mass() , expected.mass() )
self.assertEqual(actual.massSqr() , expected.massSqr() )
self.assertEqual(actual.mt() , expected.mt() )
self.assertEqual(actual.mtSqr() , expected.mtSqr() )
self.assertEqual(actual.px() , expected.px() )
self.assertEqual(actual.py() , expected.py() )
self.assertEqual(actual.pz() , expected.pz() )
self.assertAlmostEqual(actual.pt(), expected.pt(), 5)
self.assertEqual(actual.phi() , expected.phi() )
self.assertEqual(actual.theta() , expected.theta() )
self.assertEqual(actual.eta() , expected.eta() )
# self.assertEqual(actual.rapidity() , expected.rapidity() )
# self.assertEqual(actual.y() , expected.y() )
self.assertEqual(actual.vx() , expected.vx() )
self.assertEqual(actual.vy() , expected.vy() )
self.assertEqual(actual.vz() , expected.vz() )
# int
self.assertEqual(actual.pdgId() , expected.pdgId() )
self.assertEqual(actual.status() , expected.status() )
# bool
self.assertEqual(actual.longLived() , expected.longLived() )
self.assertEqual(actual.massConstraint() , expected.massConstraint() )
# double
self.assertEqual(actual.vertexChi2() , expected.vertexChi2() )
self.assertEqual(actual.vertexNdof() , expected.vertexNdof() )
self.assertEqual(actual.vertexNormalizedChi2() , expected.vertexNormalizedChi2() )
# bool
self.assertEqual(actual.hasMasterClone() , expected.hasMasterClone() )
self.assertEqual(actual.hasMasterClonePtr() , expected.hasMasterClonePtr() )
self.assertEqual(actual.isElectron() , expected.isElectron() )
self.assertEqual(actual.isMuon() , expected.isMuon() )
self.assertEqual(actual.isStandAloneMuon() , expected.isStandAloneMuon() )
self.assertEqual(actual.isGlobalMuon() , expected.isGlobalMuon() )
self.assertEqual(actual.isTrackerMuon() , expected.isTrackerMuon() )
self.assertEqual(actual.isCaloMuon() , expected.isCaloMuon() )
self.assertEqual(actual.isPhoton() , expected.isPhoton() )
self.assertEqual(actual.isConvertedPhoton() , expected.isConvertedPhoton() )
self.assertEqual(actual.isJet() , expected.isJet() )
def analyze(deltaR, relPt, stNum):
# deltaR: DeltaR of the matching cone
# relPt: allowed relative pT deviation (1 = no deviation, 0 = infinit deviation)
for file in fileList:
event = [threading.Event(), threading.Event()]
eventList.append(event)
t = threading.Thread(target=downloadAll)
t.start()
ROOT.gROOT.SetStyle('Plain') # white background
## PLOTS ##
# Only RECO working / L1 working
qualityCodes = ROOT.TH1D("QualityCodes", "QualityCodes", 100, -1.5, 98.5)
qualityCodes2d = ROOT.TH2D("Quality Codes 2D", "Quality Codes 2D", 20, -10.5, 9.5, 10, -5.5, 4.5)
qualityCodes2dWrong = ROOT.TH2D("Quality Codes 2D Wrong", "Quality Codes 2D Wrong", 20, -10.5, 9.5, 10, -5.5, 4.5)
realPtVsL1Pt = ROOT.TH2D("Real Pt vs L1 HO Pt", "Real Pt vs L1 HO Pt", 100, 0, 500, 100, 0, 500)
realPhiVsL1Phi = ROOT.TH2D("Real Phi vs L1 HO Pt", "Real Phi vs L1 HO Pt", 100, -.5, .5, 100, -.5, .5)
realEtaVsL1Eta = ROOT.TH2D("Real Eta vs L1 HO Pt", "Real Eta vs L1 HO Pt", 100, -.5, .5, 100, -.5, .5)
recoPositionOfMuons = ROOT.TH2D("Reco Position", "Reco Position", 100, -.5, .5, 628, -1.*math.pi, math.pi)
genPositionsOfRecMuons = ROOT.TH2D("Gen Position of reconstructed muons", "Gen Position of reconstructed muons", 100, -.5, .5, 628, -1.*math.pi, math.pi)
numberOfFails = 0
numberOfRecoveries = 0
numberOfRecEvents = 0
numberOfTooMany = 0
for f in range(len(fileList)):
eventList[f][0].wait()#warten auf beide events event.wait()
eventList[f][1].wait()
print 'Files ', fileList[f][0], ' and ', fileList[f][1], ' are ready... analyzing them'
eventsBad = Events(fileList[f][1]) #sample with dead MB1
eventsGood = Events(fileList[f][0])
eventsBad.toBegin()
eventsGood.toBegin()
eventsGood_iter = eventsGood.__iter__()
eventsBad_iter = eventsBad.__iter__()
for i in xrange(MAX_NUMBER):
# GET THE EVENTS
badEvent = eventsBad_iter.next()
goodEvent = eventsGood_iter.next()
# GET THE HANDLES
badEvent.getByLabel(label,badMuonsHandle)
badRecoMuons = badMuonsHandle.product()
goodEvent.getByLabel(labelGenParticles, genParticlesHandle)
genParticles = genParticlesHandle.product()
badEvent.getByLabel(labelL1, badL1MuonsHandle)
badL1Muons = badL1MuonsHandle.product()
goodEvent.getByLabel(label,goodMuonsHandle)
goodRecoMuons = goodMuonsHandle.product()
goodEvent.getByLabel(labelL1, goodL1MuonsHandle)
goodL1Muons = goodL1MuonsHandle.product()
badEvent.getByLabel(labelHoEntries, hoEntriesHandle)
badHoEntries = hoEntriesHandle.product()
badEvent.getByLabel(labelPhiContainer, phiContainerHandle)
phiContainer = phiContainerHandle.product()
#----- END GET THE HANDLES -----
badEvent.getByLabel(labelPhiContainer, phiContainerHandle)
phiContainer = phiContainerHandle.product()
#----- END GET THE HANDLES -----
phiDigis = phiContainer.getContainer()
badEvent.getByLabel(labelThContainer, thContainerHandle)
thContainer = thContainerHandle.product()
#----- END GET THE HANDLES -----
thDigis = thContainer.getContainer()
l1MuonTuple = []
recoMuon = 0
matchingBadMuon = 1 #L1Muon
matchingGoodMuon = 2 #L1Muon
matchedToGenRecoMuon = Utils.getMatch(genParticles[0], goodRecoMuons, .1, .7)
#print matchedToGenRecoMuon, " Matched to"
for element in goodRecoMuons:
if Utils.isInRange(element):
thisTuple = [element, Utils.getMatch(element, badL1Muons, deltaR, relPt), Utils.getMatch(element, goodL1Muons, deltaR, relPt)]
l1MuonTuple.append(thisTuple)
for j in range(len(l1MuonTuple)):
element = l1MuonTuple[j]
if not element[matchingGoodMuon] == None:
if element[matchingBadMuon] == None:
if abs(element[recoMuon].eta()) < Utils.getEta(3.85, 1.28):
if element[recoMuon].phi() >= -10.*math.pi/180. and element[recoMuon].phi() < 20./180.*math.pi:
numberOfFails = numberOfFails + 1
print 'Event ' + str(i) + ', RECO (gen), pT: ', str(element[recoMuon].pt()), ' eta: ', str(element[recoMuon].eta()), 'phi ', str(element[recoMuon].phi())
if printDigis(phiDigis, thDigis):
candidates = getMuonCandidates(phiDigis, thDigis, badHoEntries, qualityCodes2d, stNum)
if candidates:
numberOfRecEvents = numberOfRecEvents+1
for c in candidates:
c.printInfo()
qualityCodes.Fill(c.quality)
realPtVsL1Pt.Fill(element[recoMuon].pt(), c.pt)
realPhiVsL1Phi.Fill(element[recoMuon].phi(), c.phi)
realEtaVsL1Eta.Fill(element[recoMuon].eta(), c.eta)
recoPositionOfMuons.Fill(c.eta, c.phi)
numberOfRecoveries = numberOfRecoveries + 1
if not candidates:
qualityCodes.Fill(-1)
if candidates:
genPositionsOfRecMuons.Fill(element[recoMuon].eta(), element[recoMuon].phi())
print '--------------------------- '
else:
if printDigis(phiDigis, thDigis):
candidates = getMuonCandidates(phiDigis, thDigis, badHoEntries, qualityCodes2dWrong, stNum) #change plots!
for c in candidates:
c.printInfo()
if len(c) > 1:
numberOfTooMany = numberOfTooMany + 1
# Here we have the muons that are detected in L1 for the working detector, but are not detected in the non working detector anymore
# element[recoMuon] is the corresponding RECO muon (meaning the 'GEN' muon)
#files Loeschen
print 'Removing file: ', fileList[f][1]
os.remove(fileList[f][1]) #sample with dead MB1
print 'Removing file: ', fileList[f][0]
os.remove(fileList[f][0])
print 'Number of additional fails: ', str(numberOfFails)
print 'Number of recovered events: ', str(numberOfRecEvents)
print 'Number of recoveries : ' , str(numberOfRecoveries)
save('Quality.root', qualityCodes, realPtVsL1Pt, realPhiVsL1Phi, realEtaVsL1Eta, qualityCodes2d, genPositionsOfRecMuons, recoPositionOfMuons, qualityCodes2dWrong)
pick = False
if args.pick:
pick = tuple([int(i) for i in args.pick.split(':')])
import ROOT
import pprint
from DataFormats.FWLite import Events, Handle
from pdb import set_trace
ROOT.gROOT.SetBatch()
fname = args.file
if fname.startswith('/store/'):
fname = 'root://cmsxrootd-site.fnal.gov/%s' % fname
events = Events(fname)
iterator = events.__iter__()
handle = Handle(args.handle)
keep_going = True
loop = 0
while keep_going:
evt = iterator.next()
loop += 1
get_result = evt.getByLabel(args.label, handle)
obj = handle.product()
if pick:
evtid = (evt.eventAuxiliary().run(),
evt.eventAuxiliary().luminosityBlock(),
evt.eventAuxiliary().event())
if evtid == pick:
keep_going = False
class METProducerTest(unittest.TestCase):
def setUp(self):
self.exEvents = Events([options.expectedPath])
self.acEvents = Events([options.actualPath])
self.exHandleCorrMETData = Handle("CorrMETData")
self.acHandleCorrMETData = Handle("CorrMETData")
def test_n_events(self):
self.assertEqual(self.exEvents.size(), self.acEvents.size())
def test_corrCaloMetType2(self):
label = ("corrCaloMetType2", "", "CORR")
self.assert_CorrMETData(label)
def test_corrPfMetShiftXY(self):
label = ("corrPfMetShiftXY", "", "CORR")
self.assert_CorrMETData(label)
def test_corrPfMetType0RecoTrack(self):
label = ("corrPfMetType0RecoTrack", "", "CORR")
self.assert_CorrMETData(label)
def test_corrPfMetType0RecoTrackForType2(self):
label = ("corrPfMetType0RecoTrackForType2", "", "CORR")
self.assert_CorrMETData(label)
def test_corrPfMetType2(self):
label = ("corrPfMetType2", "", "CORR")
self.assert_CorrMETData(label)
def test_corrPfMetType1_offset(self):
label = ("corrPfMetType1", "offset", "CORR")
self.assert_CorrMETData(label)
def test_corrPfMetType1_type1(self):
label = ("corrPfMetType1", "type1", "CORR")
self.assert_CorrMETData(label)
def test_corrPfMetType1_type2(self):
label = ("corrPfMetType1", "type2", "CORR")
self.assert_CorrMETData(label)
def test_pfCandMETcorr(self):
label = ("pfCandMETcorr", "", "CORR")
self.assert_CorrMETData(label)
def test_pfchsMETcorr_type0(self):
label = ("pfchsMETcorr", "type0", "CORR")
self.assert_CorrMETData(label)
def test_corrPfMetType0PfCand(self):
label = ("corrPfMetType0PfCand", "", "CORR")
self.assert_CorrMETData(label)
def test_muonCaloMETcorr(self):
label = ("muonCaloMETcorr", "", "CORR")
self.assert_CorrMETData(label)
def test_corrCaloMetType1_offset(self):
label = ("corrCaloMetType1", "offset", "CORR")
self.assert_CorrMETData(label)
def test_corrCaloMetType1_type1(self):
label = ("corrCaloMetType1", "type1", "CORR")
self.assert_CorrMETData(label)
def test_corrCaloMetType1_type2(self):
label = ("corrCaloMetType1", "type2", "CORR")
self.assert_CorrMETData(label)
def assert_CorrMETData(self, label):
exHandle = self.exHandleCorrMETData
acHandle = self.acHandleCorrMETData
exEventIter = self.exEvents.__iter__()
acEventIter = self.acEvents.__iter__()
nevents = min(self.exEvents.size(), self.acEvents.size())
for i in range(nevents):
exEvent = exEventIter.next()
acEvent = acEventIter.next()
exEvent.getByLabel(label, exHandle)
exCorr = exHandle.product()
acEvent.getByLabel(label, acHandle)
acCorr = acHandle.product()
self.assertAlmostEqual(acCorr.mex, exCorr.mex, 12)
self.assertAlmostEqual(acCorr.mey, exCorr.mey, 12)
self.assertAlmostEqual(acCorr.sumet, exCorr.sumet, 12)
self.assertAlmostEqual(acCorr.significance, exCorr.significance,
12)
class METProducerTest(unittest.TestCase):
def setUp(self):
self.exEvents = Events([options.expectedPath])
self.acEvents = Events([options.actualPath])
self.exHandleGenMETs = Handle("std::vector<reco::GenMET>")
self.exHandlePFMETs = Handle("std::vector<reco::PFMET>")
self.exHandleCaloMETs = Handle("std::vector<reco::CaloMET>")
self.exHandleMETs = Handle("std::vector<reco::MET>")
self.exHandlePFClusterMETs = Handle("std::vector<reco::PFClusterMET>")
self.acHandleGenMETs = Handle("std::vector<reco::GenMET>")
self.acHandlePFMETs = Handle("std::vector<reco::PFMET>")
self.acHandleCaloMETs = Handle("std::vector<reco::CaloMET>")
self.acHandleMETs = Handle("std::vector<reco::MET>")
self.acHandlePFClusterMETs = Handle("std::vector<reco::PFClusterMET>")
def test_n_events(self):
self.assertEqual(self.exEvents.size(), self.acEvents.size())
def test_recoPFMETs_pfMetT0rt(self):
label = ("pfMetT0rt", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT1(self):
label = ("pfMetT0rtT1", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT1T2(self):
label = ("pfMetT0rtT1T2", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT2(self):
label = ("pfMetT0rtT2", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0pc(self):
label = ("pfMetT0pc", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0pcT1(self):
label = ("pfMetT0pcT1", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT1(self):
label = ("pfMetT1", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT1T2(self):
label = ("pfMetT1T2", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtTxy(self):
label = ("pfMetT0rtTxy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT1Txy(self):
label = ("pfMetT0rtT1Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT1T2Txy(self):
label = ("pfMetT0rtT1T2Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0rtT2Txy(self):
label = ("pfMetT0rtT2Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0pcTxy(self):
label = ("pfMetT0pcTxy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT0pcT1Txy(self):
label = ("pfMetT0pcT1Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT1Txy(self):
label = ("pfMetT1Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfMetT1T2Txy(self):
label = ("pfMetT1T2Txy", "", "TEST")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_caloMetT1(self):
label = ("caloMetT1", "", "TEST")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_caloMetT1T2(self):
label = ("caloMetT1T2", "", "TEST")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def assert_collection(self, label, exHandle, acHandle,
candidateAssertMethods):
exEventIter = self.exEvents.__iter__()
acEventIter = self.acEvents.__iter__()
nevents = min(self.exEvents.size(), self.acEvents.size())
for i in range(nevents):
exEvent = exEventIter.next()
acEvent = acEventIter.next()
exEvent.getByLabel(label, exHandle)
exMETs = exHandle.product()
exMET = exMETs.front()
acEvent.getByLabel(label, acHandle)
acMETs = acHandle.product()
self.assertEqual(acMETs.size(), 1)
acMET = acMETs.front()
for method in candidateAssertMethods:
getattr(self, method)(acMET, exMET)
def assert_recoPFMET(self, actual, expected):
# double
self.assertEqual(actual.photonEtFraction(),
expected.photonEtFraction())
self.assertAlmostEqual(actual.photonEt(), expected.photonEt(), 12)
self.assertEqual(actual.neutralHadronEtFraction(),
expected.neutralHadronEtFraction())
self.assertAlmostEqual(actual.neutralHadronEt(),
expected.neutralHadronEt(), 12)
self.assertEqual(actual.electronEtFraction(),
expected.electronEtFraction())
self.assertAlmostEqual(actual.electronEt(), expected.electronEt(), 12)
self.assertEqual(actual.chargedHadronEtFraction(),
expected.chargedHadronEtFraction())
self.assertAlmostEqual(actual.chargedHadronEt(),
expected.chargedHadronEt(), 12)
self.assertEqual(actual.muonEtFraction(), expected.muonEtFraction())
self.assertAlmostEqual(actual.muonEt(), expected.muonEt(), 12)
self.assertEqual(actual.HFHadronEtFraction(),
expected.HFHadronEtFraction())
self.assertAlmostEqual(actual.HFHadronEt(), expected.HFHadronEt(), 12)
self.assertEqual(actual.HFEMEtFraction(), expected.HFEMEtFraction())
self.assertAlmostEqual(actual.HFEMEt(), expected.HFEMEt(), 12)
def assert_recoGenMET(self, actual, expected):
# double
self.assertEqual(actual.NeutralEMEtFraction(),
expected.NeutralEMEtFraction())
self.assertEqual(actual.NeutralEMEt(), expected.NeutralEMEt())
self.assertEqual(actual.ChargedEMEtFraction(),
expected.ChargedEMEtFraction())
self.assertEqual(actual.ChargedEMEt(), expected.ChargedEMEt())
self.assertEqual(actual.NeutralHadEtFraction(),
expected.NeutralHadEtFraction())
self.assertEqual(actual.NeutralHadEt(), expected.NeutralHadEt())
self.assertEqual(actual.ChargedHadEtFraction(),
expected.ChargedHadEtFraction())
self.assertEqual(actual.ChargedHadEt(), expected.ChargedHadEt())
self.assertEqual(actual.MuonEtFraction(), expected.MuonEtFraction())
self.assertEqual(actual.MuonEt(), expected.MuonEt())
self.assertEqual(actual.InvisibleEtFraction(),
expected.InvisibleEtFraction())
self.assertEqual(actual.InvisibleEt(), expected.InvisibleEt())
def assert_recoCaloMET(self, actual, expected):
# double
self.assertEqual(actual.maxEtInEmTowers(), expected.maxEtInEmTowers())
self.assertEqual(actual.maxEtInHadTowers(),
expected.maxEtInHadTowers())
self.assertAlmostEqual(actual.etFractionHadronic(),
expected.etFractionHadronic(), 15)
self.assertAlmostEqual(actual.emEtFraction(), expected.emEtFraction(),
15)
self.assertEqual(actual.hadEtInHB(), expected.hadEtInHB())
self.assertEqual(actual.hadEtInHO(), expected.hadEtInHO())
self.assertEqual(actual.hadEtInHE(), expected.hadEtInHE())
self.assertEqual(actual.hadEtInHF(), expected.hadEtInHF())
self.assertEqual(actual.emEtInEB(), expected.emEtInEB())
self.assertEqual(actual.emEtInEE(), expected.emEtInEE())
self.assertEqual(actual.emEtInHF(), expected.emEtInHF())
self.assertEqual(actual.metSignificance(), expected.metSignificance())
self.assertEqual(actual.CaloSETInpHF(), expected.CaloSETInpHF())
self.assertEqual(actual.CaloSETInmHF(), expected.CaloSETInmHF())
self.assertEqual(actual.CaloMETInpHF(), expected.CaloMETInpHF())
self.assertEqual(actual.CaloMETInmHF(), expected.CaloMETInmHF())
self.assertEqual(actual.CaloMETPhiInpHF(), expected.CaloMETPhiInpHF())
self.assertEqual(actual.CaloMETPhiInmHF(), expected.CaloMETPhiInmHF())
def assert_recoMET(self, actual, expected):
# double
self.assertAlmostEqual(actual.sumEt(), expected.sumEt(), 12)
self.assertAlmostEqual(actual.mEtSig(), expected.mEtSig(), 12)
self.assertEqual(actual.significance(), expected.significance())
self.assertEqual(actual.e_longitudinal(), expected.e_longitudinal())
self.assertEqual(actual.dmEx().size(), expected.dmEx().size())
for a, e in zip(actual.dmEx(), expected.dmEx()):
self.assertEqual(a, e)
self.assertEqual(actual.dmEy().size(), expected.dmEy().size())
for a, e in zip(actual.dmEy(), expected.dmEy()):
self.assertEqual(a, e)
self.assertEqual(actual.dsumEt().size(), expected.dsumEt().size())
for a, e in zip(actual.dsumEt(), expected.dsumEt()):
self.assertEqual(a, e)
self.assertEqual(actual.dSignificance().size(),
expected.dSignificance().size())
for a, e in zip(actual.dSignificance(), expected.dSignificance()):
self.assertEqual(a, e)
self.assertEqual(actual.mEtCorr().size(), expected.mEtCorr().size())
for a, e in zip(actual.mEtCorr(), expected.mEtCorr()):
# self.assertEqual(a.mex , e.mex)
# self.assertEqual(a.mey , e.mey)
# self.assertAlmostEqual(a.sumet , e.sumet, 4)
# self.assertEqual(a.significance , e.significance)
pass
def assert_recoLeafCandidate(self, actual, expected):
# size_t
self.assertEqual(actual.numberOfDaughters(),
expected.numberOfDaughters())
self.assertEqual(actual.numberOfMothers(), expected.numberOfMothers())
# int
self.assertEqual(actual.charge(), expected.charge())
self.assertEqual(actual.threeCharge(), expected.threeCharge())
# double
self.assertEqual(actual.p(), expected.p())
self.assertAlmostEqual(actual.energy(), expected.energy(), 10)
self.assertAlmostEqual(actual.et(), expected.et(), 10)
# self.assertEqual(actual.mass() , expected.mass() )
# self.assertEqual(actual.massSqr() , expected.massSqr() )
self.assertAlmostEqual(actual.mt(), expected.mt(), 10)
self.assertAlmostEqual(actual.mtSqr(), expected.mtSqr(), 10)
self.assertEqual(actual.px(), expected.px())
self.assertEqual(actual.py(), expected.py())
self.assertEqual(actual.pz(), expected.pz())
self.assertAlmostEqual(actual.pt(), expected.pt(), 5)
self.assertEqual(actual.phi(), expected.phi())
self.assertEqual(actual.theta(), expected.theta())
self.assertEqual(actual.eta(), expected.eta())
# self.assertEqual(actual.rapidity() , expected.rapidity() )
# self.assertEqual(actual.y() , expected.y() )
self.assertEqual(actual.vx(), expected.vx())
self.assertEqual(actual.vy(), expected.vy())
self.assertEqual(actual.vz(), expected.vz())
# int
self.assertEqual(actual.pdgId(), expected.pdgId())
self.assertEqual(actual.status(), expected.status())
# bool
self.assertEqual(actual.longLived(), expected.longLived())
self.assertEqual(actual.massConstraint(), expected.massConstraint())
# double
self.assertEqual(actual.vertexChi2(), expected.vertexChi2())
self.assertEqual(actual.vertexNdof(), expected.vertexNdof())
self.assertEqual(actual.vertexNormalizedChi2(),
expected.vertexNormalizedChi2())
# bool
self.assertEqual(actual.hasMasterClone(), expected.hasMasterClone())
self.assertEqual(actual.hasMasterClonePtr(),
expected.hasMasterClonePtr())
self.assertEqual(actual.isElectron(), expected.isElectron())
self.assertEqual(actual.isMuon(), expected.isMuon())
self.assertEqual(actual.isStandAloneMuon(),
expected.isStandAloneMuon())
self.assertEqual(actual.isGlobalMuon(), expected.isGlobalMuon())
self.assertEqual(actual.isTrackerMuon(), expected.isTrackerMuon())
self.assertEqual(actual.isCaloMuon(), expected.isCaloMuon())
self.assertEqual(actual.isPhoton(), expected.isPhoton())
self.assertEqual(actual.isConvertedPhoton(),
expected.isConvertedPhoton())
self.assertEqual(actual.isJet(), expected.isJet())
class TBFileReader:
def __init__(self, filename, **optional):
if not os.path.exists(filename):
sys.exit("** file not found: %s" % filename)
# cache input variables
self.filename = filename
# create options by scanning file
print "reading file %s ..." % filename
os.system("edmDumpEventContent %s >& .dumpevent" % filename)
records = open(".dumpevent").readlines()
for ii, record in enumerate(records):
if record[:4] != "----": continue
records = records[ii+1:]
break
objects = {}
for ii, record in enumerate(records):
record = simplify.sub(">", strip(record))
t = split(record)
s = extract.findall(record)
if len(s) > 0:
name = s[0]
else:
name = t[0]
objects[name] = (t[0], dequote.sub("",t[1]), dequote.sub("",t[2]))
# create event buffer, get event iterator,
# and create handles
self.events = Events(filename)
self.iter = self.events.__iter__()
self.event = self.iter.next()
self.numberOfEvents = self.event.size()
print "\n Number of events: %d" % self.numberOfEvents
self.handles= {}
print " %-20s %s" % ("Key", "Type")
print "-"*78
keys = objects.keys()
keys.sort()
for key in keys:
edmtype, label1, label2 = objects[key]
h = Handle(edmtype)
self.handles[key] = h
print " %-20s %s" % (key, edmtype)
self.entry = 0
self.buffer = {}
self.objects = objects
self.keys = keys
def __del__(self):
pass
# read event at specified index in TFile and
# cache requested objects
def read(self, index):
if index < 0: return False
if index > self.numberOfEvents-1: return False
self.event.to(index)
for key in self.keys:
handle = self.handles[key]
if handle == None: continue
edmtype, module, label = self.objects[key]
self.event.getByLabel(module, label, handle)
self.buffer[key] = handle.product()
self.entry += 1
return True
# get next event and cache requested objects
def next(self):
try:
self.event = self.iter.next()
except StopIteration:
return False
for key in self.keys:
handle = self.handles[key]
if handle == None: continue
edmtype, module, label = self.objects[key]
self.event.getByLabel(module, label, handle)
self.buffer[key] = handle.product()
self.entry += 1
return True
# return object by key
def __call__(self, key):
try:
return self.buffer[key]
except:
return None
def entries(self):
return self.numberOfEvents
def names(self):
return self.keys()
def __len__(self):
return self.entries()
class METProducerTest(unittest.TestCase):
def setUp(self):
self.exEvents = Events([options.expectedPath])
self.acEvents = Events([options.actualPath])
self.exHandleCorrMETData = Handle("CorrMETData")
self.acHandleCorrMETData = Handle("CorrMETData")
self.nameChangeMap = {
"pfJetMETcorr" : "corrPfMetType1",
"pfMETcorrType0" : "corrPfMetType0PfCand",
"caloJetMETcorr" : "corrCaloMetType1",
"pfCandMETcorr" : "pfCandMETcorr",
"pfchsMETcorr" : "pfchsMETcorr",
"muonCaloMETcorr" : "muonCaloMETcorr",
}
def test_n_events(self):
self.assertEqual(self.exEvents.size(), self.acEvents.size())
def test_pfJetMETcorr_offset(self):
label = ("pfJetMETcorr", "offset", "CORR")
self.assert_CorrMETData(label)
def test_pfJetMETcorr_type1(self):
label = ("pfJetMETcorr", "type1", "CORR")
self.assert_CorrMETData(label)
def test_pfJetMETcorr_type2(self):
label = ("pfJetMETcorr", "type2", "CORR")
self.assert_CorrMETData(label)
def test_pfCandMETcorr(self):
label = ("pfCandMETcorr", "", "CORR")
self.assert_CorrMETData(label)
def test_pfchsMETcorr_type0(self):
label = ("pfchsMETcorr", "type0", "CORR")
self.assert_CorrMETData(label)
def test_pfMETcorrType0(self):
label = ("pfMETcorrType0", "", "CORR")
self.assert_CorrMETData(label)
def test_muonCaloMETcorr(self):
label = ("muonCaloMETcorr", "", "CORR")
self.assert_CorrMETData(label)
def test_caloJetMETcorr_offset(self):
label = ("caloJetMETcorr", "offset", "CORR")
self.assert_CorrMETData(label)
def test_caloJetMETcorr_type1(self):
label = ("caloJetMETcorr", "type1", "CORR")
self.assert_CorrMETData(label)
def test_caloJetMETcorr_type2(self):
label = ("caloJetMETcorr", "type2", "CORR")
self.assert_CorrMETData(label)
def assert_CorrMETData(self, label):
exHandle = self.exHandleCorrMETData
acHandle = self.acHandleCorrMETData
exEventIter = self.exEvents.__iter__()
acEventIter = self.acEvents.__iter__()
nevents = min(self.exEvents.size(), self.acEvents.size())
for i in range(nevents):
exEvent = exEventIter.next()
acEvent = acEventIter.next()
exEvent.getByLabel(label, exHandle)
exCorr = exHandle.product()
aclabel = list(label)
aclabel[0] = self.nameChangeMap[aclabel[0]]
acEvent.getByLabel(aclabel, acHandle)
acCorr = acHandle.product()
self.assertAlmostEqual(acCorr.mex, exCorr.mex, 12)
self.assertAlmostEqual(acCorr.mey, exCorr.mey, 12)
self.assertAlmostEqual(acCorr.sumet, exCorr.sumet, 12)
self.assertAlmostEqual(acCorr.significance, exCorr.significance, 12)
class METProducerTest(unittest.TestCase):
def setUp(self):
self.exEvents = Events([options.expectedPath])
self.acEvents = Events([options.actualPath])
self.exHandleGenMETs = Handle("std::vector<reco::GenMET>")
self.exHandlePFMETs = Handle("std::vector<reco::PFMET>")
self.exHandleCaloMETs = Handle("std::vector<reco::CaloMET>")
self.exHandleMETs = Handle("std::vector<reco::MET>")
self.exHandlePFClusterMETs = Handle("std::vector<reco::PFClusterMET>")
self.acHandleGenMETs = Handle("std::vector<reco::GenMET>")
self.acHandlePFMETs = Handle("std::vector<reco::PFMET>")
self.acHandleCaloMETs = Handle("std::vector<reco::CaloMET>")
self.acHandleMETs = Handle("std::vector<reco::MET>")
self.acHandlePFClusterMETs = Handle("std::vector<reco::PFClusterMET>")
def test_n_events(self):
self.assertEqual(self.exEvents.size(), self.acEvents.size())
def test_recoPFMETs_pfMet(self):
label = ("pfMet", "", "METP")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoGenMETs_genMetTrue(self):
label = ("genMetTrue", "", "METP")
exHandle = self.exHandleGenMETs
acHandle = self.acHandleGenMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoGenMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoGenMETs_genMetCalo(self):
label = ("genMetCalo", "", "METP")
exHandle = self.exHandleGenMETs
acHandle = self.acHandleGenMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoGenMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoGenMETs_genMetCaloAndNonPrompt(self):
label = ("genMetCaloAndNonPrompt", "", "METP")
exHandle = self.exHandleGenMETs
acHandle = self.acHandleGenMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoGenMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoMETs_genMetIC5GenJets(self):
label = ("genMetIC5GenJets", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoMETs_tcMet(self):
label = ("tcMet", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoMETs_tcMetCST(self):
label = ("tcMetCST", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoMETs_tcMetRft2(self):
label = ("tcMetRft2", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoMETs_tcMetVedu(self):
label = ("tcMetVedu", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoMETs_tcMetWithPFclusters(self):
label = ("tcMetWithPFclusters", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoMETs_htMetAK5(self):
label = ("htMetAK5", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
# def test_recoMETs_htMetAK7(self):
# label = ("htMetAK7", "", "METP")
# exHandle = self.exHandleMETs
# acHandle = self.acHandleMETs
# candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
# self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
# def test_recoMETs_htMetKT4(self):
# label = ("htMetKT4", "", "METP")
# exHandle = self.exHandleMETs
# acHandle = self.acHandleMETs
# candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
# self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoMETs_htMetKT6(self):
label = ("htMetKT6", "", "METP")
exHandle = self.exHandleMETs
acHandle = self.acHandleMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
# def test_recoMETs_htMetIC5(self):
# label = ("htMetIC5", "", "METP")
# exHandle = self.exHandleMETs
# acHandle = self.acHandleMETs
# candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
# self.assert_collection(label, exHandle, acHandle, candidateAssertMethods)
def test_recoCaloMETs_met(self):
label = ("met", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_metHO(self):
label = ("metHO", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_metNoHF(self):
label = ("metNoHF", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_metNoHFHO(self):
label = ("metNoHFHO", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_metOpt(self):
label = ("metOpt", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_metOptHO(self):
label = ("metOptHO", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_metOptNoHF(self):
label = ("metOptNoHF", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_metOptNoHFHO(self):
label = ("metOptNoHFHO", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoCaloMETs_corMetGlobalMuons(self):
label = ("corMetGlobalMuons", "", "METP")
exHandle = self.exHandleCaloMETs
acHandle = self.exHandleCaloMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoCaloMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFClusterMETs_pfClusterMet(self):
label = ("pfClusterMet", "", "METP")
exHandle = self.exHandlePFClusterMETs
acHandle = self.acHandlePFClusterMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def test_recoPFMETs_pfChargedMET(self):
label = ("pfChargedMET", "", "METP")
exHandle = self.exHandlePFMETs
acHandle = self.acHandlePFMETs
candidateAssertMethods = ('assert_recoLeafCandidate', 'assert_recoMET',
'assert_recoPFMET')
self.assert_collection(label, exHandle, acHandle,
candidateAssertMethods)
def assert_collection(self, label, exHandle, acHandle,
candidateAssertMethods):
exEventIter = self.exEvents.__iter__()
acEventIter = self.acEvents.__iter__()
nevents = min(self.exEvents.size(), self.acEvents.size())
for i in range(nevents):
exEvent = exEventIter.next()
acEvent = acEventIter.next()
exEvent.getByLabel(label, exHandle)
exMETs = exHandle.product()
exMET = exMETs.front()
acEvent.getByLabel(label, acHandle)
acMETs = acHandle.product()
self.assertEqual(acMETs.size(), 1)
acMET = acMETs.front()
for method in candidateAssertMethods:
getattr(self, method)(acMET, exMET)
def assert_recoPFMET(self, actual, expected):
# double
self.assertEqual(actual.photonEtFraction(),
expected.photonEtFraction())
self.assertAlmostEqual(actual.photonEt(), expected.photonEt(), 10)
self.assertEqual(actual.neutralHadronEtFraction(),
expected.neutralHadronEtFraction())
self.assertAlmostEqual(actual.neutralHadronEt(),
expected.neutralHadronEt(), 10)
self.assertEqual(actual.electronEtFraction(),
expected.electronEtFraction())
self.assertAlmostEqual(actual.electronEt(), expected.electronEt(), 10)
self.assertEqual(actual.chargedHadronEtFraction(),
expected.chargedHadronEtFraction())
self.assertAlmostEqual(actual.chargedHadronEt(),
expected.chargedHadronEt(), 10)
self.assertEqual(actual.muonEtFraction(), expected.muonEtFraction())
self.assertAlmostEqual(actual.muonEt(), expected.muonEt(), 10)
self.assertEqual(actual.HFHadronEtFraction(),
expected.HFHadronEtFraction())
self.assertAlmostEqual(actual.HFHadronEt(), expected.HFHadronEt(), 10)
self.assertEqual(actual.HFEMEtFraction(), expected.HFEMEtFraction())
self.assertAlmostEqual(actual.HFEMEt(), expected.HFEMEt(), 10)
def assert_recoGenMET(self, actual, expected):
# double
self.assertEqual(actual.NeutralEMEtFraction(),
expected.NeutralEMEtFraction())
self.assertEqual(actual.NeutralEMEt(), expected.NeutralEMEt())
self.assertEqual(actual.ChargedEMEtFraction(),
expected.ChargedEMEtFraction())
self.assertEqual(actual.ChargedEMEt(), expected.ChargedEMEt())
self.assertEqual(actual.NeutralHadEtFraction(),
expected.NeutralHadEtFraction())
self.assertEqual(actual.NeutralHadEt(), expected.NeutralHadEt())
self.assertEqual(actual.ChargedHadEtFraction(),
expected.ChargedHadEtFraction())
self.assertEqual(actual.ChargedHadEt(), expected.ChargedHadEt())
self.assertEqual(actual.MuonEtFraction(), expected.MuonEtFraction())
self.assertEqual(actual.MuonEt(), expected.MuonEt())
self.assertEqual(actual.InvisibleEtFraction(),
expected.InvisibleEtFraction())
self.assertEqual(actual.InvisibleEt(), expected.InvisibleEt())
def assert_recoCaloMET(self, actual, expected):
# double
self.assertEqual(actual.maxEtInEmTowers(), expected.maxEtInEmTowers())
self.assertEqual(actual.maxEtInHadTowers(),
expected.maxEtInHadTowers())
self.assertAlmostEqual(actual.etFractionHadronic(),
expected.etFractionHadronic(), 15)
self.assertAlmostEqual(actual.emEtFraction(), expected.emEtFraction(),
15)
self.assertEqual(actual.hadEtInHB(), expected.hadEtInHB())
self.assertEqual(actual.hadEtInHO(), expected.hadEtInHO())
self.assertEqual(actual.hadEtInHE(), expected.hadEtInHE())
self.assertEqual(actual.hadEtInHF(), expected.hadEtInHF())
self.assertEqual(actual.emEtInEB(), expected.emEtInEB())
self.assertEqual(actual.emEtInEE(), expected.emEtInEE())
self.assertEqual(actual.emEtInHF(), expected.emEtInHF())
self.assertEqual(actual.metSignificance(), expected.metSignificance())
self.assertEqual(actual.CaloSETInpHF(), expected.CaloSETInpHF())
self.assertEqual(actual.CaloSETInmHF(), expected.CaloSETInmHF())
self.assertEqual(actual.CaloMETInpHF(), expected.CaloMETInpHF())
self.assertEqual(actual.CaloMETInmHF(), expected.CaloMETInmHF())
self.assertEqual(actual.CaloMETPhiInpHF(), expected.CaloMETPhiInpHF())
self.assertEqual(actual.CaloMETPhiInmHF(), expected.CaloMETPhiInmHF())
def assert_recoMET(self, actual, expected):
# double
self.assertAlmostEqual(actual.sumEt(), expected.sumEt(), 10)
self.assertAlmostEqual(actual.mEtSig(), expected.mEtSig(), 10)
self.assertEqual(actual.significance(), expected.significance())
self.assertEqual(actual.e_longitudinal(), expected.e_longitudinal())
self.assertEqual(actual.dmEx().size(), expected.dmEx().size())
for a, e in zip(actual.dmEx(), expected.dmEx()):
self.assertEqual(a, e)
self.assertEqual(actual.dmEy().size(), expected.dmEy().size())
for a, e in zip(actual.dmEy(), expected.dmEy()):
self.assertEqual(a, e)
self.assertEqual(actual.dsumEt().size(), expected.dsumEt().size())
for a, e in zip(actual.dsumEt(), expected.dsumEt()):
self.assertEqual(a, e)
self.assertEqual(actual.dSignificance().size(),
expected.dSignificance().size())
for a, e in zip(actual.dSignificance(), expected.dSignificance()):
self.assertEqual(a, e)
self.assertEqual(actual.mEtCorr().size(), expected.mEtCorr().size())
for a, e in zip(actual.mEtCorr(), expected.mEtCorr()):
# self.assertEqual(a.mex , e.mex)
# self.assertEqual(a.mey , e.mey)
# self.assertEqual(a.sumet , e.sumet)
# self.assertEqual(a.significance , e.significance)
pass
actualSigMatrix = actual.getSignificanceMatrix()
expectedSigMatrix = expected.getSignificanceMatrix()
self.assertEqual(actualSigMatrix.GetNrows(),
expectedSigMatrix.GetNrows())
self.assertEqual(actualSigMatrix.GetNcols(),
expectedSigMatrix.GetNcols())
self.assertEqual(actualSigMatrix.GetNoElements(),
expectedSigMatrix.GetNoElements())
for irow in range(actualSigMatrix.GetNrows()):
for icol in range(actualSigMatrix.GetNcols()):
self.assertEqual(actualSigMatrix(irow, icol),
expectedSigMatrix(irow, icol))
def assert_recoLeafCandidate(self, actual, expected):
# size_t
self.assertEqual(actual.numberOfDaughters(),
expected.numberOfDaughters())
self.assertEqual(actual.numberOfMothers(), expected.numberOfMothers())
# int
self.assertEqual(actual.charge(), expected.charge())
self.assertEqual(actual.threeCharge(), expected.threeCharge())
# double
self.assertEqual(actual.p(), expected.p())
self.assertEqual(actual.energy(), expected.energy())
self.assertEqual(actual.et(), expected.et())
self.assertEqual(actual.mass(), expected.mass())
self.assertEqual(actual.massSqr(), expected.massSqr())
self.assertEqual(actual.mt(), expected.mt())
self.assertEqual(actual.mtSqr(), expected.mtSqr())
self.assertEqual(actual.px(), expected.px())
self.assertEqual(actual.py(), expected.py())
self.assertEqual(actual.pz(), expected.pz())
self.assertAlmostEqual(actual.pt(), expected.pt(), 5)
self.assertEqual(actual.phi(), expected.phi())
self.assertEqual(actual.theta(), expected.theta())
self.assertEqual(actual.eta(), expected.eta())
# self.assertEqual(actual.rapidity() , expected.rapidity() )
# self.assertEqual(actual.y() , expected.y() )
self.assertEqual(actual.vx(), expected.vx())
self.assertEqual(actual.vy(), expected.vy())
self.assertEqual(actual.vz(), expected.vz())
# int
self.assertEqual(actual.pdgId(), expected.pdgId())
self.assertEqual(actual.status(), expected.status())
# bool
self.assertEqual(actual.longLived(), expected.longLived())
self.assertEqual(actual.massConstraint(), expected.massConstraint())
# double
self.assertEqual(actual.vertexChi2(), expected.vertexChi2())
self.assertEqual(actual.vertexNdof(), expected.vertexNdof())
self.assertEqual(actual.vertexNormalizedChi2(),
expected.vertexNormalizedChi2())
# bool
self.assertEqual(actual.hasMasterClone(), expected.hasMasterClone())
self.assertEqual(actual.hasMasterClonePtr(),
expected.hasMasterClonePtr())
self.assertEqual(actual.isElectron(), expected.isElectron())
self.assertEqual(actual.isMuon(), expected.isMuon())
self.assertEqual(actual.isStandAloneMuon(),
expected.isStandAloneMuon())
self.assertEqual(actual.isGlobalMuon(), expected.isGlobalMuon())
self.assertEqual(actual.isTrackerMuon(), expected.isTrackerMuon())
self.assertEqual(actual.isCaloMuon(), expected.isCaloMuon())
self.assertEqual(actual.isPhoton(), expected.isPhoton())
self.assertEqual(actual.isConvertedPhoton(),
expected.isConvertedPhoton())
self.assertEqual(actual.isJet(), expected.isJet())
def analyze(deltaR, relPt, stNum):
# deltaR: DeltaR of the matching cone
# relPt: allowed relative pT deviation (1 = no deviation, 0 = infinit deviation)
for file in fileList:
event = [threading.Event(), threading.Event()]
eventList.append(event)
t = threading.Thread(target=downloadAll)
t.start()
ROOT.gROOT.SetStyle('Plain') # white background
## PLOTS ##
# Only RECO working / L1 working
qualityCodes = ROOT.TH1D("QualityCodes", "QualityCodes", 100, -1.5, 98.5)
qualityCodes2d = ROOT.TH2D("Quality Codes 2D", "Quality Codes 2D", 20,
-10.5, 9.5, 10, -5.5, 4.5)
qualityCodes2dWrong = ROOT.TH2D("Quality Codes 2D Wrong",
"Quality Codes 2D Wrong", 20, -10.5, 9.5,
10, -5.5, 4.5)
realPtVsL1Pt = ROOT.TH2D("Real Pt vs L1 HO Pt", "Real Pt vs L1 HO Pt", 100,
0, 500, 100, 0, 500)
realPhiVsL1Phi = ROOT.TH2D("Real Phi vs L1 HO Pt", "Real Phi vs L1 HO Pt",
100, -.5, .5, 100, -.5, .5)
realEtaVsL1Eta = ROOT.TH2D("Real Eta vs L1 HO Pt", "Real Eta vs L1 HO Pt",
100, -.5, .5, 100, -.5, .5)
recoPositionOfMuons = ROOT.TH2D("Reco Position", "Reco Position", 100, -.5,
.5, 628, -1. * math.pi, math.pi)
genPositionsOfRecMuons = ROOT.TH2D("Gen Position of reconstructed muons",
"Gen Position of reconstructed muons",
100, -.5, .5, 628, -1. * math.pi,
math.pi)
numberOfFails = 0
numberOfRecoveries = 0
numberOfRecEvents = 0
numberOfTooMany = 0
for f in range(len(fileList)):
eventList[f][0].wait() #warten auf beide events event.wait()
eventList[f][1].wait()
print 'Files ', fileList[f][0], ' and ', fileList[f][
1], ' are ready... analyzing them'
eventsBad = Events(fileList[f][1]) #sample with dead MB1
eventsGood = Events(fileList[f][0])
eventsBad.toBegin()
eventsGood.toBegin()
eventsGood_iter = eventsGood.__iter__()
eventsBad_iter = eventsBad.__iter__()
for i in xrange(MAX_NUMBER):
# GET THE EVENTS
badEvent = eventsBad_iter.next()
goodEvent = eventsGood_iter.next()
# GET THE HANDLES
badEvent.getByLabel(label, badMuonsHandle)
badRecoMuons = badMuonsHandle.product()
goodEvent.getByLabel(labelGenParticles, genParticlesHandle)
genParticles = genParticlesHandle.product()
badEvent.getByLabel(labelL1, badL1MuonsHandle)
badL1Muons = badL1MuonsHandle.product()
goodEvent.getByLabel(label, goodMuonsHandle)
goodRecoMuons = goodMuonsHandle.product()
goodEvent.getByLabel(labelL1, goodL1MuonsHandle)
goodL1Muons = goodL1MuonsHandle.product()
badEvent.getByLabel(labelHoEntries, hoEntriesHandle)
badHoEntries = hoEntriesHandle.product()
badEvent.getByLabel(labelPhiContainer, phiContainerHandle)
phiContainer = phiContainerHandle.product()
#----- END GET THE HANDLES -----
badEvent.getByLabel(labelPhiContainer, phiContainerHandle)
phiContainer = phiContainerHandle.product()
#----- END GET THE HANDLES -----
phiDigis = phiContainer.getContainer()
badEvent.getByLabel(labelThContainer, thContainerHandle)
thContainer = thContainerHandle.product()
#----- END GET THE HANDLES -----
thDigis = thContainer.getContainer()
l1MuonTuple = []
recoMuon = 0
matchingBadMuon = 1 #L1Muon
matchingGoodMuon = 2 #L1Muon
matchedToGenRecoMuon = Utils.getMatch(genParticles[0],
goodRecoMuons, .1, .7)
#print matchedToGenRecoMuon, " Matched to"
for element in goodRecoMuons:
if Utils.isInRange(element):
thisTuple = [
element,
Utils.getMatch(element, badL1Muons, deltaR, relPt),
Utils.getMatch(element, goodL1Muons, deltaR, relPt)
]
l1MuonTuple.append(thisTuple)
for j in range(len(l1MuonTuple)):
element = l1MuonTuple[j]
if not element[matchingGoodMuon] == None:
if element[matchingBadMuon] == None:
if abs(element[recoMuon].eta()) < Utils.getEta(
3.85, 1.28):
if element[recoMuon].phi(
) >= -10. * math.pi / 180. and element[
recoMuon].phi() < 20. / 180. * math.pi:
numberOfFails = numberOfFails + 1
print 'Event ' + str(
i) + ', RECO (gen), pT: ', str(
element[recoMuon].pt()), ' eta: ', str(
element[recoMuon].eta()
), 'phi ', str(element[recoMuon].phi())
if printDigis(phiDigis, thDigis):
candidates = getMuonCandidates(
phiDigis, thDigis, badHoEntries,
qualityCodes2d, stNum)
if candidates:
numberOfRecEvents = numberOfRecEvents + 1
for c in candidates:
c.printInfo()
qualityCodes.Fill(c.quality)
realPtVsL1Pt.Fill(
element[recoMuon].pt(), c.pt)
realPhiVsL1Phi.Fill(
element[recoMuon].phi(), c.phi)
realEtaVsL1Eta.Fill(
element[recoMuon].eta(), c.eta)
recoPositionOfMuons.Fill(c.eta, c.phi)
numberOfRecoveries = numberOfRecoveries + 1
if not candidates:
qualityCodes.Fill(-1)
if candidates:
genPositionsOfRecMuons.Fill(
element[recoMuon].eta(),
element[recoMuon].phi())
print '--------------------------- '
else:
if printDigis(phiDigis, thDigis):
candidates = getMuonCandidates(
phiDigis, thDigis, badHoEntries,
qualityCodes2dWrong, stNum) #change plots!
for c in candidates:
c.printInfo()
if len(c) > 1:
numberOfTooMany = numberOfTooMany + 1
# Here we have the muons that are detected in L1 for the working detector, but are not detected in the non working detector anymore
# element[recoMuon] is the corresponding RECO muon (meaning the 'GEN' muon)
#files Loeschen
print 'Removing file: ', fileList[f][1]
os.remove(fileList[f][1]) #sample with dead MB1
print 'Removing file: ', fileList[f][0]
os.remove(fileList[f][0])
print 'Number of additional fails: ', str(numberOfFails)
print 'Number of recovered events: ', str(numberOfRecEvents)
print 'Number of recoveries : ', str(numberOfRecoveries)
save('Quality.root', qualityCodes, realPtVsL1Pt, realPhiVsL1Phi,
realEtaVsL1Eta, qualityCodes2d, genPositionsOfRecMuons,
recoPositionOfMuons, qualityCodes2dWrong)
