From fa29e56ae0f81ce8f7d907594ff80ee2671aa744 Mon Sep 17 00:00:00 2001 From: Suvankar Roy Chowdhury Date: Mon, 29 Dec 2014 15:00:42 +0530 Subject: [PATCH 1/7] Treemaker Code for MINIAODSIM --- AnalysisSpace/TreeMaker/BuildFile.xml | 30 + .../TreeMaker/interface/PhysicsObjects.h | 523 +++ AnalysisSpace/TreeMaker/interface/Utility.h | 14 + AnalysisSpace/TreeMaker/plugins/BuildFile.xml | 5 + .../TreeMaker/plugins/ElectronBlock.cc | 270 ++ .../TreeMaker/plugins/ElectronBlock.h | 58 + AnalysisSpace/TreeMaker/plugins/EventBlock.cc | 198 ++ AnalysisSpace/TreeMaker/plugins/EventBlock.h | 60 + .../TreeMaker/plugins/GenEventBlock.cc | 83 + .../TreeMaker/plugins/GenEventBlock.h | 39 + .../TreeMaker/plugins/GenJetBlock.cc | 63 + AnalysisSpace/TreeMaker/plugins/GenJetBlock.h | 41 + .../TreeMaker/plugins/GenMETBlock.cc | 58 + AnalysisSpace/TreeMaker/plugins/GenMETBlock.h | 44 + .../TreeMaker/plugins/GenParticleBlock.cc | 144 + .../TreeMaker/plugins/GenParticleBlock.h | 42 + .../TreeMaker/plugins/HLTEventAnalyzer.cc | 156 + .../TreeMaker/plugins/HLTEventAnalyzer.h | 36 + AnalysisSpace/TreeMaker/plugins/JetBlock.cc | 109 + AnalysisSpace/TreeMaker/plugins/JetBlock.h | 46 + AnalysisSpace/TreeMaker/plugins/METBlock.cc | 85 + AnalysisSpace/TreeMaker/plugins/METBlock.h | 59 + AnalysisSpace/TreeMaker/plugins/MuonBlock.cc | 258 ++ AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ | 255 ++ AnalysisSpace/TreeMaker/plugins/MuonBlock.h | 51 + AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ | 51 + .../TreeMaker/plugins/PhotonBlock.cc | 172 + AnalysisSpace/TreeMaker/plugins/PhotonBlock.h | 48 + AnalysisSpace/TreeMaker/plugins/TauBlock.cc | 240 ++ AnalysisSpace/TreeMaker/plugins/TauBlock.h | 53 + .../TreeMaker/plugins/TreeMakerModule.cc | 37 + .../TreeMaker/plugins/TreeMakerModule.h | 26 + .../TreeMaker/plugins/TriggerBlock.cc | 109 + .../TreeMaker/plugins/TriggerBlock.h | 51 + .../TreeMaker/plugins/TriggerObjectBlock.cc | 117 + .../TreeMaker/plugins/TriggerObjectBlock.h | 60 + .../TreeMaker/plugins/VertexBlock.cc | 86 + AnalysisSpace/TreeMaker/plugins/VertexBlock.h | 40 + .../TreeMaker/python/ElectronBlock_cfi.py | 9 + .../TreeMaker/python/ElectronBlock_cfi.pyc | Bin 0 -> 596 bytes .../TreeMaker/python/EventBlock_cfi.py | 18 + .../TreeMaker/python/EventBlock_cfi.pyc | Bin 0 -> 946 bytes .../TreeMaker/python/GenEventBlock_cfi.py | 8 + .../TreeMaker/python/GenEventBlock_cfi.pyc | Bin 0 -> 566 bytes .../TreeMaker/python/GenJetBlock_cfi.py | 6 + .../TreeMaker/python/GenJetBlock_cfi.pyc | Bin 0 -> 423 bytes .../TreeMaker/python/GenMETBlock_cfi.py | 6 + .../TreeMaker/python/GenMETBlock_cfi.pyc | Bin 0 -> 419 bytes .../TreeMaker/python/GenParticleBlock_cfi.py | 6 + .../TreeMaker/python/GenParticleBlock_cfi.pyc | Bin 0 -> 447 bytes .../TreeMaker/python/JetBlock_cfi.py | 9 + .../TreeMaker/python/JetBlock_cfi.pyc | Bin 0 -> 678 bytes .../TreeMaker/python/METBlock_cfi.py | 8 + .../TreeMaker/python/METBlock_cfi.pyc | Bin 0 -> 521 bytes .../TreeMaker/python/MuonBlock_cfi.py | 10 + .../TreeMaker/python/MuonBlock_cfi.pyc | Bin 0 -> 644 bytes .../TreeMaker/python/TauBlock_cfi.py | 9 + .../TreeMaker/python/TauBlock_cfi.pyc | Bin 0 -> 574 bytes .../TreeMaker/python/TreeContentConfig_cff.py | 31 + .../python/TreeContentConfig_cff.pyc | Bin 0 -> 1206 bytes .../python/TreeContentConfig_data_cff.py | 23 + .../python/TreeContentConfig_data_cff.pyc | Bin 0 -> 1117 bytes .../TreeMaker/python/TreeCreator_cfi.py | 6 + .../TreeMaker/python/TreeCreator_cfi.pyc | Bin 0 -> 411 bytes .../TreeMaker/python/TreeWriter_cfi.py | 7 + .../TreeMaker/python/TreeWriter_cfi.pyc | Bin 0 -> 410 bytes .../TreeMaker/python/TriggerBlock_cfi.py | 14 + .../TreeMaker/python/TriggerBlock_cfi.pyc | Bin 0 -> 672 bytes .../python/TriggerObjectBlock_cfi.py | 33 + .../python/TriggerObjectBlock_cfi.pyc | Bin 0 -> 1182 bytes .../TreeMaker/python/VertexBlock_cfi.py | 6 + .../TreeMaker/python/VertexBlock_cfi.pyc | Bin 0 -> 438 bytes AnalysisSpace/TreeMaker/python/__init__.py | 3 + AnalysisSpace/TreeMaker/python/__init__.pyc | Bin 0 -> 394 bytes AnalysisSpace/TreeMaker/src/PhysicsObjects.cc | 388 +++ AnalysisSpace/TreeMaker/src/Utility.cc | 15 + AnalysisSpace/TreeMaker/src/classes.h | 39 + AnalysisSpace/TreeMaker/src/classes.h.save | 32 + AnalysisSpace/TreeMaker/src/classes_def.xml | 59 + .../TreeMaker/test/IntegrationTest_cfg.py | 95 + .../test/IntegrationTest_cfg.py.save | 0 .../test/IntegrationTest_cfg.py.save.1 | 94 + ...uTau_M_125_TuneZ2star_13TeV_pythia6_cff.py | 60 + .../TreeMaker/test/miniAOD-prod_PAT.py | 91 + AnalysisSpace/TreeMaker/test/pat.py | 95 + AnalysisSpace/TreeMaker/test/test.py | 92 + AnalysisSpace/TreeMaker/test/tmp.txt | 2972 +++++++++++++++++ 87 files changed, 8061 insertions(+) create mode 100644 AnalysisSpace/TreeMaker/BuildFile.xml create mode 100644 AnalysisSpace/TreeMaker/interface/PhysicsObjects.h create mode 100644 AnalysisSpace/TreeMaker/interface/Utility.h create mode 100644 AnalysisSpace/TreeMaker/plugins/BuildFile.xml create mode 100644 AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/ElectronBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/EventBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/EventBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/GenEventBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/GenJetBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/GenJetBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/GenMETBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/GenMETBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/GenParticleBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/GenParticleBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.h create mode 100644 AnalysisSpace/TreeMaker/plugins/JetBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/JetBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/METBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/METBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/MuonBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ create mode 100644 AnalysisSpace/TreeMaker/plugins/MuonBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ create mode 100644 AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/PhotonBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/TauBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/TauBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/TreeMakerModule.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/TreeMakerModule.h create mode 100644 AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/TriggerBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h create mode 100644 AnalysisSpace/TreeMaker/plugins/VertexBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/VertexBlock.h create mode 100644 AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/EventBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/EventBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/GenEventBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/GenEventBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/GenJetBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/GenJetBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/GenMETBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/GenMETBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/GenParticleBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/GenParticleBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/JetBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/JetBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/METBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/METBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/MuonBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/MuonBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/TauBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/TauBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/TreeContentConfig_cff.py create mode 100644 AnalysisSpace/TreeMaker/python/TreeContentConfig_cff.pyc create mode 100644 AnalysisSpace/TreeMaker/python/TreeContentConfig_data_cff.py create mode 100644 AnalysisSpace/TreeMaker/python/TreeContentConfig_data_cff.pyc create mode 100644 AnalysisSpace/TreeMaker/python/TreeCreator_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/TreeCreator_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/TreeWriter_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/TreeWriter_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/TriggerBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/TriggerBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/VertexBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/VertexBlock_cfi.pyc create mode 100644 AnalysisSpace/TreeMaker/python/__init__.py create mode 100644 AnalysisSpace/TreeMaker/python/__init__.pyc create mode 100644 AnalysisSpace/TreeMaker/src/PhysicsObjects.cc create mode 100644 AnalysisSpace/TreeMaker/src/Utility.cc create mode 100644 AnalysisSpace/TreeMaker/src/classes.h create mode 100644 AnalysisSpace/TreeMaker/src/classes.h.save create mode 100644 AnalysisSpace/TreeMaker/src/classes_def.xml create mode 100644 AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py create mode 100644 AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py.save create mode 100644 AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py.save.1 create mode 100644 AnalysisSpace/TreeMaker/test/WH_ZH_HToTauTau_M_125_TuneZ2star_13TeV_pythia6_cff.py create mode 100644 AnalysisSpace/TreeMaker/test/miniAOD-prod_PAT.py create mode 100644 AnalysisSpace/TreeMaker/test/pat.py create mode 100644 AnalysisSpace/TreeMaker/test/test.py create mode 100644 AnalysisSpace/TreeMaker/test/tmp.txt diff --git a/AnalysisSpace/TreeMaker/BuildFile.xml b/AnalysisSpace/TreeMaker/BuildFile.xml new file mode 100644 index 0000000..054791f --- /dev/null +++ b/AnalysisSpace/TreeMaker/BuildFile.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h new file mode 100644 index 0000000..dfb6bbc --- /dev/null +++ b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h @@ -0,0 +1,523 @@ +#ifndef __AnalysisSpace_TreeMaker_PhysicsObjects_h +#define __AnalysisSpace_TreeMaker_PhysicsObjects_h + +#include +#include +#include + +#include "TObject.h" + +namespace vhtm { + class Candidate: public TObject { + public: + Candidate(); + Candidate(float pt, float eta, float phi); + virtual ~Candidate() {} + + float pt; + float eta; + float phi; + + ClassDef(Candidate,1) + }; + class Event: public TObject { + public: + Event(); + virtual ~Event() {} + + unsigned int run; + unsigned int event; + unsigned int lumis; + unsigned int bunch; + unsigned int orbit; + double time; + bool isdata; + + bool isPhysDeclared; + bool isBPTX0; + bool isBSCMinBias; + bool isBSCBeamHalo; + bool isPrimaryVertex; + //bool isBeamScraping; + bool passHBHENoiseFilter; + + double rho; + double rhoNeutral; + int nvtx; + + std::vector nPU; + std::vector bunchCrossing; + std::vector trueNInt; + + ClassDef(Event,1) + }; + class GenEvent: public TObject { + public: + GenEvent(); + virtual ~GenEvent() {} + + unsigned int processID; + double ptHat; + std::vector pdfWeights; + + ClassDef(GenEvent,1) + }; + + class Electron: public TObject { + public: + Electron(); + ~Electron() {} + double eta; + double phi; + double pt; + bool ecalDriven; + bool hasGsfTrack; + double trackPt; + double energy; + double caloEnergy; + int charge; + int pixHits; + int trkHits; + int nValidHits; + double trkD0; + double trkDz; + // ID variables + double hoe; + double eop; + double sigmaEtaEta; + double sigmaIEtaIEta; + double deltaPhiTrkSC; + double deltaEtaTrkSC; + int classif; + + // Vertex + double vx; + double vy; + double vz; + + // SC associated with electron + double scEn; + double scEta; + double scPhi; + double scET; + double scRawEnergy; + + // Vertex association variables + double dxyPV; + double dzPV; + double vtxDist3D; + int vtxIndex; + double vtxDistZ; + float relIso; + float pfRelIso; + // PFlow isolation variable + float chargedHadronIso; + float neutralHadronIso; + float photonIso; + + float sumChargedHadronPt; + float sumPUPt; + + int missingHits; + + double dB; + int nBrems; + float fbrem; + + float hasMatchedConv; + bool mvaPreselection; + bool isTriggerElectron; + int fidFlag; + std::map idmap; + int selbit; + + ClassDef(Electron, 1) + }; + class GenParticle: public TObject { + public: + GenParticle(); + ~GenParticle() {} + + double eta; + double phi; + double p; + double px; + double py; + double pz; + double pt; + double energy; + int pdgId; + double vx; + double vy; + double vz; + int status; + double charge; + int numDaught; + int numMother; + int motherIndex; + std::vector motherIndices; + std::vector daughtIndices; + + ClassDef(GenParticle,1) + }; + class GenJet: public TObject { + public: + GenJet(); + ~GenJet() {} + + double eta; + double phi; + double p; + double pt; + double energy; + double emf; + double hadf; + + ClassDef(GenJet,1) + }; + class MET: public TObject { + public: + MET(); + ~MET() {} + + double met; + double metphi; + double sumet; + double metuncorr; + double metphiuncorr; + double sumetuncorr; + + ClassDef(MET,1) + }; + class Tau: public TObject { + public: + Tau(); + ~Tau() {} + + double eta; + double phi; + double pt; + double energy; + int charge; + double mass; + + double dxyPV; + double dzPV; + int vtxIndex; + double vtxDxy; + double vtxDz; + + // Leading particle pT + double leadChargedParticlePt; + double leadNeutralParticlePt; + double leadParticlePt; + + std::vector sigChHadList; + std::vector sigNeHadList; + std::vector sigGammaList; + std::vector isoChHadList; + std::vector isoNeHadList; + std::vector isoGammaList; + + float ptSumChargedHadronsIsoCone; + float ptSumNeutralHadronsIsoCone; + float ptSumPhotonsIsoCone; + + // tau id. discriminators + float decayModeFinding; + float decayModeFindingNewDMs; + float decayModeFindingOldDMs; + + // discriminators against electrons/muons + float againstMuonLoose; + float againstMuonMedium; + float againstMuonTight; + + float againstMuonLoose3; + float againstMuonTight3; + + float againstElectronLoose; + float againstElectronMedium; + float againstElectronTight; + //float againstElectronMVA; + + float againstElectronLooseMVA5; + float againstElectronMediumMVA5; + float againstElectronTightMVA5; + + float byLooseCombinedIsolationDeltaBetaCorr3Hits; + float byMediumCombinedIsolationDeltaBetaCorr3Hits; + float byTightCombinedIsolationDeltaBetaCorr3Hits; + float byCombinedIsolationDeltaBetaCorrRaw3Hits; + float chargedIsoPtSum; + float neutralIsoPtSum; + float puCorrPtSum; + + // kinematic variables for PFJet associated to PFTau + double jetPt; + double jetEta; + double jetPhi; + float emFraction; + double vx; + double vy; + double vz; + + double zvertex; + double dxySig; + int selbit; + + ClassDef(Tau, 1) + }; + class Muon: public TObject { + public: + Muon(); + ~Muon() {} + bool isTrackerMuon; + bool isPFMuon; + double eta; + double phi; + double pt; + + double p; + double energy; + int charge; + double trkD0; + + double trkDz; + + double globalChi2; + float trkIso; + float ecalIso; + float hcalIso; + float hoIso; + float pfChargedIsoR03; + float sumPUPt03; + float pfRelIso03; + float pfChargedIsoR04; + float sumPUPt04; + float pfRelIso04; + + int passID; + double dxyPV; + double dzPV; + double vtxDist3D; + int vtxIndex; + double vtxDistZ; + int pixHits; + int trkHits; + int muoHits; + int matches; + int trackerLayersWithMeasurement; + + double vx; + double vy; + double vz; + + double dB; // PV2D + + // UW Recommendation + bool isGlobalMuonPromptTight; + bool isAllArbitrated; + int nChambers; + int nMatches; + int nMatchedStations; + + unsigned int stationMask; + unsigned int stationGapMaskDistance; + unsigned int stationGapMaskPull; + + bool muonID; + + int selbit; + std::map< double,std::vector > isolationMap; + ClassDef(Muon, 1) +// ClassDef(Muon, 2) + }; + class Jet: public TObject { + public: + Jet(); + ~Jet() {} + double eta; + double phi; + double pt; + double pt_raw; + double energy; + double energy_raw; + double jecUnc; + double resJEC; + int partonFlavour; + + float chargedEmEnergyFraction; + float chargedHadronEnergyFraction; + float chargedMuEnergyFraction; + float electronEnergyFraction; + float muonEnergyFraction; + float neutralEmEnergyFraction; + float neutralHadronEnergyFraction; + float photonEnergyFraction; + int chargedHadronMultiplicity; + int chargedMultiplicity; + int electronMultiplicity; + int muonMultiplicity; + int neutralHadronMultiplicity; + int neutralMultiplicity; + int photonMultiplicity; + int nConstituents; + + //float simpleSecondaryVertexHighEffBTag; + //float simpleSecondaryVertexHighPurBTag; + + float combinedSecondaryVertexBTag; + //double combinedSecondaryVertexMVABTag; + float combinedInclusiveSecondaryVertexBTag; + //double combinedMVABTag; + std::map discrimap; + + int passLooseID; + int passTightID; + + int selbit; + + ClassDef(Jet, 1) + }; + class Vertex: public TObject { + public: + Vertex(); + virtual ~Vertex() {} + + double x; + double y; + double z; + double xErr; + double yErr; + double zErr; + double rho; + double chi2; + double ndf; + //int ntracks; + //int ntracksw05; + bool isfake; + bool isvalid; + //double sumPt; // vector sum + + int selbit; + + ClassDef(Vertex, 1) + }; + class GenMET: public TObject { + public: + GenMET(); + virtual ~GenMET() {} + + double met; + double metphi; + double sumet; + + ClassDef(GenMET, 1) + }; + class TriggerObject: public TObject { + public: + TriggerObject(); + virtual ~TriggerObject() {} + + double energy; + double pt; + double eta; + double phi; + + std::map pathList; + + ClassDef(TriggerObject, 1) + }; + class Photon : public TObject { + public: + Photon(); + virtual ~Photon() {} + + double et; + double eta; + double clusterEta; + double phi; + double clusterPhi; + double energy; + double theta; + double vx; + double vy; + double vz; + + double scEnergy; + double scEta; + double scPhi; + double scSize; + double scEtaWidth; + double scPhiWidth; + double scEt; + double scRawEnergy; + double scx; + double scy; + double scz; + double isoEcalRecHit03; + double isoHcalRecHit03; + double isoSolidTrkCone03; + double isoHollowTrkCone03; + int nTrkSolidCone03; + int nTrkHollowCone03; + + double isoEcalRecHit04; + double isoHcalRecHit04; + double isoSolidTrkCone04; + double isoHollowTrkCone04; + int nTrkSolidCone04; + int nTrkHollowCone04; + + bool isEB; + bool isEE; + bool isEBGap; + bool isEEGap; + bool isEBEEGap; + int fidFlag; + + bool hasPixelSeed; + double ecalIso; + double hcalIso; + double trackIso; + double chargedHadIso; + double neutralHadIso; + double photonIso; + + double r9; + double hoe; + double sigmaEtaEta; + double sigmaIEtaIEta; + double e1x5; + double e2x5; + double e3x3; + double e5x5; + double r1x5; + double r2x5; + double maxEnergyXtal; + + bool hasConversionTracks; + int nTracks; + bool isConverted; + double pairInvMass; + double pairCotThetaSeparation; + double pairPx; + double pairPy; + double pairPz; + double conv_vx; + double conv_vy; + double conv_vz; + double eovp; + double zpv; + double distOfMinApproach; + double dPhiTracksAtVtx; + double dPhiTracksAtEcal; + double dEtaTracksAtEcal; + + int selbit; + + ClassDef(Photon, 1) + }; +} +#endif diff --git a/AnalysisSpace/TreeMaker/interface/Utility.h b/AnalysisSpace/TreeMaker/interface/Utility.h new file mode 100644 index 0000000..264615e --- /dev/null +++ b/AnalysisSpace/TreeMaker/interface/Utility.h @@ -0,0 +1,14 @@ +#ifndef __AnalysisSpace_TreeMaker_Utility_h +#define __AnalysisSpace_TreeMaker_Utility_h + +#include + +class TTree; + +namespace vhtm { + class Utility { + public: + static TTree* getTree(const std::string& tree_name="vhtree"); + }; +} +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/BuildFile.xml b/AnalysisSpace/TreeMaker/plugins/BuildFile.xml new file mode 100644 index 0000000..1c097c5 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/BuildFile.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc new file mode 100644 index 0000000..dcffe86 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc @@ -0,0 +1,270 @@ +#include +#include + +#include "TFile.h" +#include "TTree.h" +#include "TROOT.h" +#include "TVector3.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "DataFormats/GsfTrackReco/interface/GsfTrack.h" +#include "DataFormats/TrackReco/interface/HitPattern.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/VertexReco/interface/Vertex.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/ElectronBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +// Constructor +ElectronBlock::ElectronBlock(const edm::ParameterSet& iConfig): + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + bsCorr_(iConfig.getUntrackedParameter("beamSpotCorr", false)), + bsTag_(iConfig.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), + vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), + electronTag_(iConfig.getUntrackedParameter("electronSrc", edm::InputTag("selectedPatElectrons"))), + bsToken_(consumes(bsTag_)), + vertexToken_(consumes(vertexTag_)), + electronToken_(consumes(electronTag_)) +{ +} +ElectronBlock::~ElectronBlock() { +} +void ElectronBlock::beginJob() +{ + // Get TTree pointer + std::string tree_name = "vhtree"; + TTree* tree = vhtm::Utility::getTree(tree_name); + list_ = new std::vector(); + tree->Branch("Electron", "std::vector", &list_, 32000, 2); + tree->Branch("nElectron", &fnElectron_, "fnElectron_/I"); +} +void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnElectron_ = 0; + + edm::Handle electrons; + bool found = iEvent.getByToken(electronToken_, electrons); + + if (found && electrons.isValid()) { + edm::Handle beamSpot; + if (bsCorr_) iEvent.getByToken(bsToken_, beamSpot); + + edm::Handle primaryVertices; + iEvent.getByToken(vertexToken_, primaryVertices); + + edm::LogInfo("ElectronBlock") << "Total # PAT Electrons: " << electrons->size(); + for (const pat::Electron& v: *electrons) { + if (list_->size() == kMaxElectron_) { + edm::LogInfo("ElectronBlock") << "Too many PAT Electrons, fnElectron = " + << list_->size(); + break; + } + bool hasGsfTrack = v.gsfTrack().isNonnull() ? true : false; + + vhtm::Electron electron; + electron.ecalDriven = v.ecalDrivenSeed(); + electron.eta = v.eta(); + electron.phi = v.phi(); + electron.pt = v.pt(); + electron.hasGsfTrack = hasGsfTrack; + electron.energy = v.energy(); + electron.caloEnergy = v.ecalEnergy(); + electron.charge = v.charge(); + + float nMissingHits = 0; + double dxyWrtPV = -99.; + double dzWrtPV = -99.; + + if (hasGsfTrack) { + reco::GsfTrackRef tk = v.gsfTrack(); + electron.trackPt = tk->pt(); + + // Hit pattern + const reco::HitPattern& hitp = tk->hitPattern(); + electron.pixHits = hitp.numberOfValidPixelHits(); + electron.trkHits = hitp.numberOfValidTrackerHits(); + + electron.nValidHits = tk->numberOfValidHits(); + nMissingHits = tk->trackerExpectedHitsInner().numberOfHits(); + electron.missingHits = nMissingHits; + + double trkd0 = tk->d0(); + double trkdz = tk->dz(); + if (bsCorr_) { + if (beamSpot.isValid()) { + trkd0 = -(tk->dxy(beamSpot->position())); + trkdz = tk->dz(beamSpot->position()); + } + else + edm::LogError("ElectronBlock") << "Error >> Failed to get BeamSpot for label: " + << bsTag_; + } + electron.trkD0 = trkd0; + electron.trkDz = trkdz; + + if (primaryVertices.isValid()) { + const reco::Vertex& vit = primaryVertices->front(); // Highest sumPt vertex + dxyWrtPV = tk->dxy(vit.position()); + dzWrtPV = tk->dz(vit.position()); + electron.dxyPV = dxyWrtPV; + electron.dzPV = dzWrtPV; + + // Vertex association + double minVtxDist3D = 9999.; + int indexVtx = -1; + double vertexDistZ = 9999.; + edm::LogInfo("ElectronBlock") << "Total # Primary Vertices: " << primaryVertices->size(); + for (auto vit = primaryVertices->begin(); vit != primaryVertices->end(); ++vit) { + double dxy = tk->dxy(vit->position()); + double dz = tk->dz(vit->position()); + double dist3D = std::sqrt(pow(dxy, 2) + pow(dz, 2)); + if (dist3D < minVtxDist3D) { + minVtxDist3D = dist3D; + indexVtx = int(std::distance(primaryVertices->begin(), vit)); + vertexDistZ = dz; + } + } + electron.vtxDist3D = minVtxDist3D; + electron.vtxIndex = indexVtx; + electron.vtxDistZ = vertexDistZ; + } + else { + edm::LogError("ElectronBlock") << "Error >> Failed to get VertexCollection for label: " + << vertexTag_; + } + } + // ID variables + float dPhi = v.deltaPhiSuperClusterTrackAtVtx(); + float dEta = v.deltaEtaSuperClusterTrackAtVtx(); + float sihih = v.sigmaIetaIeta(); + float hoe = v.hadronicOverEm(); // v.hcalOverEcal(); + + electron.hoe = hoe; + electron.eop = v.eSuperClusterOverP(); + electron.sigmaEtaEta = v.sigmaEtaEta(); + electron.sigmaIEtaIEta = sihih; + electron.deltaPhiTrkSC = dPhi; + electron.deltaEtaTrkSC = dEta; + electron.classif = v.classification(); + + // SC associated with electron + electron.scEn = v.superCluster()->energy(); + electron.scEta = v.superCluster()->eta(); + electron.scPhi = v.superCluster()->phi(); + electron.scET = v.superCluster()->energy()/cosh(v.superCluster()->eta()); + electron.scRawEnergy = v.superCluster()->rawEnergy(); + + electron.relIso = (v.trackIso() + v.ecalIso() + v.hcalIso())/v.pt(); + + // PF Isolation + reco::GsfElectron::PflowIsolationVariables pfIso = v.pfIsolationVariables(); + electron.sumChargedHadronPt = pfIso.sumChargedHadronPt; + electron.sumPUPt = pfIso.sumPUPt; + float absiso = pfIso.sumChargedHadronPt + std::max(0.0, pfIso.sumNeutralHadronEt + pfIso.sumPhotonEt - 0.5 * pfIso.sumPUPt); + float iso = absiso/(v.p4().pt()); + electron.pfRelIso = iso; + + // isolation information + electron.chargedHadronIso = v.chargedHadronIso(); + electron.neutralHadronIso = v.neutralHadronIso(); + electron.photonIso = v.photonIso(); + + // IP information + electron.dB = v.dB(pat::Electron::PV2D); + + // Bremstrahlung information + electron.nBrems = v.numberOfBrems(); + electron.fbrem = v.fbrem(); + + // other useful quantities + bool myTrigPresel = false; + double pt = v.pt(); + if (std::abs(v.superCluster()->eta()) < 1.485) { + if (sihih < 0.014 && + hoe < 0.15 && + v.dr03TkSumPt()/pt < 0.2 && + v.dr03EcalRecHitSumEt()/pt < 0.2 && + v.dr03HcalTowerSumEt()/pt < 0.2 && + nMissingHits == 0) + myTrigPresel = true; + } + else { + if (sihih < 0.035 && + hoe < 0.10 && + v.dr03TkSumPt()/pt < 0.2 && + v.dr03EcalRecHitSumEt()/pt < 0.2 && + v.dr03HcalTowerSumEt()/pt < 0.2 && + nMissingHits == 0) + myTrigPresel = true; + } + electron.mvaPreselection = myTrigPresel; + + int flagEB = (v.isEB() ? 1 : 0); + int flagEE = (v.isEE() ? 1 : 0); + bool passconv = v.passConversionVeto(); + electron.hasMatchedConv = (passconv ? false : true); + + bool mvaPreselection = passconv && nMissingHits <= 0 && dxyWrtPV < 0.02 && dzWrtPV < 0.1 && + ((flagEB + && sihih < 0.01 + && std::fabs(dEta) < 0.007 + && std::fabs(dPhi) < 0.15 + && hoe < 0.12 + && v.dr03TkSumPt()/pt < 0.20 + && (std::max(v.dr03EcalRecHitSumEt() - 1.0, 0.0))/pt < 0.20 + && v.dr03HcalTowerSumEt()/pt < 0.20 + ) || + (flagEE + && sihih < 0.03 + && std::fabs(dEta) < 0.009 + && std::fabs(dPhi) < 0.10 + && hoe < 0.10 + && v.dr03TkSumPt()/pt < 0.20 + && (std::max(v.dr03EcalRecHitSumEt() - 1.0, 0.0))/pt < 0.20 + && v.dr03HcalTowerSumEt()/pt < 0.20 + )); + electron.isTriggerElectron = mvaPreselection; + + // Fiducial flag + int fidFlag = 0; + if (v.isEB()) fidFlag |= (1 << 0); + if (v.isEE()) fidFlag |= (1 << 1); + if (v.isEBEtaGap()) fidFlag |= (1 << 2); + if (v.isEBPhiGap()) fidFlag |= (1 << 3); + if (v.isEERingGap()) fidFlag |= (1 << 4); + if (v.isEEDeeGap()) fidFlag |= (1 << 5); + if (v.isEBEEGap()) fidFlag |= (1 << 6); + electron.fidFlag = fidFlag; + + // Vertex information + const reco::Candidate::Point& vertex = v.vertex(); + electron.vx = vertex.x(); + electron.vy = vertex.y(); + electron.vz = vertex.z(); + +#if 0 + std::cout << "electronID(\"eidLoose\")=" << v.electronID("eidLoose") << std::endl; + std::cout << "electronID(\"eidTight\")=" << v.electronID("eidTight") << std::endl; + std::cout << "electronID(\"eidRobustLoose\")=" << v.electronID("eidRobustLoose") << std::endl; + std::cout << "electronID(\"eidRobustRight\")=" << v.electronID("eidRobustTight") << std::endl; + std::cout << "electronID(\"eidRobustHighEnergy\")=" << v.electronID("eidRobustHighEnergy") << std::endl; +#endif + + for (const pat::Electron::IdPair& pa: v.electronIDs()) + electron.idmap[pa.first] = pa.second; + + list_->push_back(electron); + } + fnElectron_ = list_->size(); + } + else { + edm::LogError("ElectronBlock") << "Error >> Failed to get pat::Electron Collection for label: " + << electronTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(ElectronBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h new file mode 100644 index 0000000..a474fa6 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h @@ -0,0 +1,58 @@ +#ifndef __AnalysisSpace_TreeMaker_ElectronBlock_h +#define __AnalysisSpace_TreeMaker_ElectronBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/Common/interface/Ref.h" + +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Provenance/interface/EventID.h" +#include "FWCore/ParameterSet/interface/ProcessDesc.h" + +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" +#include "DataFormats/EgammaCandidates/interface/GsfElectron.h" + +namespace vhtm { + class Electron; +} +class ElectronBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit ElectronBlock(const edm::ParameterSet& iConfig); + virtual ~ElectronBlock(); + + enum { + kMaxElectron_ = 100 + }; + +private: + std::vector* list_; + int fnElectron_; + + int verbosity_; + bool bsCorr_; + + const edm::InputTag bsTag_; + const edm::InputTag vertexTag_; + const edm::InputTag electronTag_; + + const edm::EDGetTokenT bsToken_; + const edm::EDGetTokenT vertexToken_; + const edm::EDGetTokenT electronToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/EventBlock.cc b/AnalysisSpace/TreeMaker/plugins/EventBlock.cc new file mode 100644 index 0000000..b113623 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/EventBlock.cc @@ -0,0 +1,198 @@ +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h" +#include "DataFormats/L1GlobalTrigger/interface/L1GtFdlWord.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "SimDataFormats/PileupSummaryInfo/interface/PileupSummaryInfo.h" + +#include "TTree.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/EventBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +EventBlock::EventBlock(const edm::ParameterSet& iConfig): + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + l1Tag_(iConfig.getUntrackedParameter("l1Tag", edm::InputTag("gtDigis"))), + vertexTag_(iConfig.getUntrackedParameter("vertexTag", edm::InputTag("goodOfflinePrimaryVertices"))), + //trackTag_(iConfig.getUntrackedParameter("trkTag", edm::InputTag("generalTracks"))), + selectedVertexTag_(iConfig.getUntrackedParameter("selectedVtxTag", edm::InputTag("selectedPrimaryVertices"))), + puSummaryTag_(iConfig.getUntrackedParameter("puSummaryTag", edm::InputTag("addPileupInfo"))), + rhoTag_(iConfig.getUntrackedParameter("rhoTag", edm::InputTag("kt6PFJets","rho"))), + rhoNeutralTag_(iConfig.getUntrackedParameter("rhoNeutralTag", edm::InputTag("kt6PFNeutralJetsForVtxMultReweighting", "rho"))), + vtxMinNDOF_(iConfig.getUntrackedParameter("vertexMinimumNDOF", 4)), + vtxMaxAbsZ_(iConfig.getUntrackedParameter("vertexMaxAbsZ", 24.)), + vtxMaxd0_(iConfig.getUntrackedParameter("vertexMaxd0", 2.0)), + numTracks_(iConfig.getUntrackedParameter("numTracks", 10)), + hpTrackThreshold_(iConfig.getUntrackedParameter("hpTrackThreshold", 0.25)), + l1Token_(consumes(l1Tag_)), + vertexToken_(consumes(vertexTag_)), + //trackToken_(consumes(trackTag_)), + selectedVertexToken_(consumes(selectedVertexTag_)), + puSummaryToken_(consumes >(puSummaryTag_)), + rhoToken_(consumes(rhoTag_)), + rhoNeutralToken_(consumes(rhoNeutralTag_)) +{ +} +EventBlock::~EventBlock() { + delete nPU_; + delete bunchCrossing_; + delete trueNInt_; + delete list_; +} +void EventBlock::beginJob() { + + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("Event", "std::vector", &list_, 32000, 2); + + nPU_ = new std::vector(); + tree->Branch("nPU", "std::vector", &nPU_); + + bunchCrossing_ = new std::vector(); + tree->Branch("bunchCrossing", "std::vector", &bunchCrossing_); + + trueNInt_ = new std::vector(); + tree->Branch("trueNInt", "std::vector", &trueNInt_); +} +void EventBlock::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) { + // Reset the vector + list_->clear(); + + // Clear the independent vectors + nPU_->clear(); + bunchCrossing_->clear(); + trueNInt_->clear(); + + // Create Event Object + vhtm::Event ev; + ev.run = iEvent.id().run(); + ev.event = iEvent.id().event(); + ev.lumis = iEvent.id().luminosityBlock(); + ev.bunch = iEvent.bunchCrossing(); + ev.orbit = iEvent.orbitNumber(); + + double sec = iEvent.time().value() >> 32 ; + double usec = 0xFFFFFFFF & iEvent.time().value(); + double conv = 1e6; + ev.time = sec+usec/conv; + ev.isdata = iEvent.isRealData(); + + edm::Handle l1GtReadoutRecord; + bool found = iEvent.getByToken(l1Token_, l1GtReadoutRecord); + + // Technical Trigger Part + if (found && l1GtReadoutRecord.isValid()) { + edm::LogInfo("EventBlock") << "Successfully obtained L1GlobalTriggerReadoutRecord for label: " + << l1Tag_; + + L1GtFdlWord fdlWord = l1GtReadoutRecord->gtFdlWord(); + if (fdlWord.physicsDeclared() == 1) + ev.isPhysDeclared = true; + + // BPTX0 + if (l1GtReadoutRecord->technicalTriggerWord()[0]) + ev.isBPTX0 = true; + + // MinBias + if (l1GtReadoutRecord->technicalTriggerWord()[40] || l1GtReadoutRecord->technicalTriggerWord()[41]) + ev.isBSCMinBias = true; + + // BeamHalo + if ( (l1GtReadoutRecord->technicalTriggerWord()[36] || l1GtReadoutRecord->technicalTriggerWord()[37] || + l1GtReadoutRecord->technicalTriggerWord()[38] || l1GtReadoutRecord->technicalTriggerWord()[39]) || + ((l1GtReadoutRecord->technicalTriggerWord()[42] && !l1GtReadoutRecord->technicalTriggerWord()[43]) || + (l1GtReadoutRecord->technicalTriggerWord()[43] && !l1GtReadoutRecord->technicalTriggerWord()[42])) ) + ev.isBSCBeamHalo = true; + } + else { + edm::LogError("EventBlock") << "Failed to get L1GlobalTriggerReadoutRecord for label: " + << l1Tag_; + } + + // Good Primary Vertex Part + edm::Handle primaryVertices; + found = iEvent.getByToken(vertexToken_, primaryVertices); + + if (found && primaryVertices.isValid()) { + edm::LogInfo("EventBlock") << "Total # Primary Vertices: " << primaryVertices->size(); + for (const reco::Vertex& v: *primaryVertices) { + if (!v.isFake() && + v.ndof() > vtxMinNDOF_ && + std::abs(v.z()) <= vtxMaxAbsZ_ && + std::abs(v.position().rho()) <= vtxMaxd0_) + { + ev.isPrimaryVertex = true; + break; + } + } + } + else { + edm::LogError("EventBlock") << "Error! Failed to get VertexCollection for label: " + << vertexTag_; + } +#if 0 + // Scraping Events Part + edm::Handle tracks; + found = iEvent.getByToken(trackToken_, tracks); + + if (found && tracks.isValid()) { + edm::LogInfo("EventBlock") << "Total # Tracks: " << tracks->size(); + + int numhighpurity = 0; + double fraction = 1.; + reco::TrackBase::TrackQuality trackQuality = reco::TrackBase::qualityByName("highPurity"); + if (tracks->size() > numTracks_) { + for (const reco::Track& v: *tracks) + if (v.quality(trackQuality)) numhighpurity++; + fraction = static_cast(numhighpurity)/static_cast(tracks->size()); + if (fraction < hpTrackThreshold_) + ev.isBeamScraping = true; + } + } + else { + edm::LogError("EventBlock") << "Error! Failed to get TrackCollection for label: " + << trackTag_; + } +#endif + // Access PU information + if (!iEvent.isRealData()) { + edm::Handle > puInfo; + found = iEvent.getByToken(puSummaryToken_, puInfo); + if (found && puInfo.isValid()) { + for (const PileupSummaryInfo& v: *puInfo) { + ev.bunchCrossing.push_back(v.getBunchCrossing()); // in-time and out-of-time indices + bunchCrossing_->push_back(v.getBunchCrossing()); + + ev.nPU.push_back(v.getPU_NumInteractions()); + nPU_->push_back(v.getPU_NumInteractions()); + + ev.trueNInt.push_back(v.getTrueNumInteractions()); + trueNInt_->push_back(v.getTrueNumInteractions()); + } + } + // More info about PU is here: + // https://twiki.cern.ch/twiki/bin/viewauth/CMS/PileupInformation#Accessing_PileupSummaryInfo_in_r + } +#if 0 + // Access rho + edm::Handle rho; + found = iEvent.getByToken(rhoToken_, rho); + if (found) + ev.rho = *rho; +#endif + // Access rhoNeutral + edm::Handle rhoNeutral; + found = iEvent.getByToken(rhoNeutralToken_, rhoNeutral); + if (found) ev.rhoNeutral = *rhoNeutral; + + // Vertex Container + edm::Handle spVertices; + found = iEvent.getByToken(selectedVertexToken_, spVertices); + if (found) ev.nvtx = spVertices->size(); + + list_->push_back(ev); +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(EventBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/EventBlock.h b/AnalysisSpace/TreeMaker/plugins/EventBlock.h new file mode 100644 index 0000000..38a1985 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/EventBlock.h @@ -0,0 +1,60 @@ +#ifndef __AnalysisSpace_TreeMaker_EventBlock_h +#define __AnalysisSpace_TreeMaker_EventBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" + +namespace vhtm { + class Event; +} +class EventBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup); + virtual void endJob(){} + +public: + explicit EventBlock(const edm::ParameterSet& iConfig); + virtual ~EventBlock(); + +private: + std::vector* list_; + std::vector* nPU_; + std::vector* bunchCrossing_; + std::vector* trueNInt_; + + const int verbosity_; + const edm::InputTag l1Tag_; + const edm::InputTag vertexTag_; + const edm::InputTag trackTag_; + const edm::InputTag selectedVertexTag_; + const edm::InputTag puSummaryTag_; + const edm::InputTag rhoTag_; + const edm::InputTag rhoNeutralTag_; + + const unsigned int vtxMinNDOF_; + const double vtxMaxAbsZ_; + const double vtxMaxd0_; + const unsigned int numTracks_; + const double hpTrackThreshold_; + + const edm::EDGetTokenT l1Token_; + const edm::EDGetTokenT vertexToken_; + const edm::EDGetTokenT trackToken_; + const edm::EDGetTokenT selectedVertexToken_; + const edm::EDGetTokenT > puSummaryToken_; + const edm::EDGetTokenT rhoToken_; + const edm::EDGetTokenT rhoNeutralToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc new file mode 100644 index 0000000..b18fad7 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc @@ -0,0 +1,83 @@ +#include +#include + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h" + +#include "TTree.h" +#include "TClonesArray.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/GenEventBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +GenEventBlock::GenEventBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + genEventTag_(iConfig.getUntrackedParameter("GenEventInfoInputTag", edm::InputTag("generator"))), + storePDFWeights_(iConfig.getUntrackedParameter("StorePDFWeights", true)), + pdfWeightsTag_(iConfig.getUntrackedParameter("PDFWeightsInputTag", edm::InputTag("pdfWeights","cteq66"))), + genEventToken_(consumes(genEventTag_)), + pdfWeightsToken_(consumes< std::vector >(pdfWeightsTag_)) +{ +} +GenEventBlock::~GenEventBlock() { + delete pdfWeights_; +} +void GenEventBlock::beginJob() +{ + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + + list_ = new std::vector(); + tree->Branch("GenEvent", "std::vector", &list_, 32000, 2); + + pdfWeights_ = new std::vector(); + tree->Branch("pdfWeights", "vector", &pdfWeights_); +} +void GenEventBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector + list_->clear(); + + // Clear the independent vector + pdfWeights_->clear(); + + if (!iEvent.isRealData()) { + // Create Event Object + vhtm::GenEvent genEvent; + + // GenEventInfo Part + edm::Handle genEvtInfoProduct; + iEvent.getByToken(genEventToken_, genEvtInfoProduct); + + if (genEvtInfoProduct.isValid()) { + edm::LogInfo("GenEventBlock") << "Success. Obtained GenEventInfoProduct for label: " + << genEventTag_; + genEvent.processID = genEvtInfoProduct->signalProcessID(); + genEvent.ptHat = genEvtInfoProduct->hasBinningValues() + ? genEvtInfoProduct->binningValues()[0] : 0.; + } + else { + edm::LogError("GenEventBlock") << "Error! Failed to get GenEventInfoProduct for label: " + << genEventTag_; + } + // PDF Weights Part + if (storePDFWeights_) { + edm::Handle > pdfWeightsHandle; + iEvent.getByToken(pdfWeightsToken_, pdfWeightsHandle); + + if (pdfWeightsHandle.isValid()) { + edm::LogInfo("GenEventBlock") << "Success. Obtained PDF handle for label: " + << pdfWeightsTag_; + copy(pdfWeightsHandle->begin(), pdfWeightsHandle->end(), genEvent.pdfWeights.begin()); + copy(pdfWeightsHandle->begin(), pdfWeightsHandle->end(), pdfWeights_->begin()); + } + else { + edm::LogError("GenEventBlock") << "Error! Failed to get PDF handle for label: " + << pdfWeightsTag_; + } + } + list_->push_back(genEvent); + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(GenEventBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/GenEventBlock.h b/AnalysisSpace/TreeMaker/plugins/GenEventBlock.h new file mode 100644 index 0000000..da1dbfe --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/GenEventBlock.h @@ -0,0 +1,39 @@ +#ifndef __AnalysisSpace_TreeMaker_GenEventBlock_h +#define __AnalysisSpace_TreeMaker_GenEventBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +namespace { + class GenEvent; +} +class GenEventBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup); + virtual void endJob() {} + +public: + explicit GenEventBlock(const edm::ParameterSet& iConfig); + virtual ~GenEventBlock(); + +private: + std::vector* list_; + std::vector *pdfWeights_; + + const int verbosity_; + const edm::InputTag genEventTag_; + const bool storePDFWeights_; + const edm::InputTag pdfWeightsTag_; + const edm::EDGetTokenT genEventToken_; + const edm::EDGetTokenT< std::vector > pdfWeightsToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/GenJetBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenJetBlock.cc new file mode 100644 index 0000000..a262d43 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/GenJetBlock.cc @@ -0,0 +1,63 @@ +#include + +#include "TTree.h" +#include "DataFormats/JetReco/interface/GenJetCollection.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +#include "AnalysisSpace/TreeMaker/plugins/GenJetBlock.h" +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +GenJetBlock::GenJetBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + genJetTag_(iConfig.getUntrackedParameter("genJetSrc", edm::InputTag("ak5GenJets"))), + genJetToken_(consumes(genJetTag_)) +{ +} +void GenJetBlock::beginJob() { + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("GenJet", "std::vector", &list_, 32000, 2); + tree->Branch("nGenJet", &fnGenJet_, "fnGenJet_/I"); +} +void GenJetBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnGenJet_ = 0; + + if (!iEvent.isRealData()) { + edm::Handle genJets; + bool found = iEvent.getByToken(genJetToken_, genJets); + + if (found && genJets.isValid()) { + edm::LogInfo("GenJetBlock") << "Total # GenJets: " << genJets->size(); + for (const reco::GenJet& v: *genJets) { + if (list_->size() == kMaxGenJet) { + edm::LogInfo("GenJetBlock") << "Too many Gen Jets, fnGenJet = " << list_->size(); + break; + } + vhtm::GenJet jet; + + // fill in all the vectors + jet.eta = v.eta(); + jet.phi = v.phi(); + jet.p = v.p(); + jet.pt = v.pt(); + double energy = v.energy(); + jet.energy = energy; + jet.emf = (energy > 0) ? v.emEnergy()/energy : 0; + jet.hadf = (energy > 0) ? v.hadEnergy()/energy : 0; + + list_->push_back(jet); + } + fnGenJet_ = list_->size(); + } + else { + edm::LogError("GenJetBlock") << "Error >> Failed to get GenJetCollection for label: " + << genJetTag_; + } + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(GenJetBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/GenJetBlock.h b/AnalysisSpace/TreeMaker/plugins/GenJetBlock.h new file mode 100644 index 0000000..af308e3 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/GenJetBlock.h @@ -0,0 +1,41 @@ +#ifndef __AnalysisSpace_TreeMaker_GenJetBlock_h +#define __AnalysisSpace_TreeMaker_GenJetBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +namespace vhtm { + class GenJet; +} + +class GenJetBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit GenJetBlock(const edm::ParameterSet& iConfig); + virtual ~GenJetBlock() {} + + enum { + kMaxGenJet = 100 + }; + +private: + std::vector* list_; + int fnGenJet_; + + const int verbosity_; + const edm::InputTag genJetTag_; + const edm::EDGetTokenT genJetToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/GenMETBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenMETBlock.cc new file mode 100644 index 0000000..6fc3dc8 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/GenMETBlock.cc @@ -0,0 +1,58 @@ +#include "TTree.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "DataFormats/METReco/interface/GenMET.h" +#include "DataFormats/METReco/interface/GenMETFwd.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/GenMETBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +GenMETBlock::GenMETBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + genMETTag_(iConfig.getUntrackedParameter("genMETSrc", edm::InputTag("genMetTrue"))), + genMETToken_(consumes(genMETTag_)) +{ +} +void GenMETBlock::beginJob() +{ + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("GenMET", "std::vector", &list_, 32000, 2); + tree->Branch("nGenMET", &fnGenMET_, "fnGenMET_/I"); +} +void GenMETBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and nObj variables + list_->clear(); + fnGenMET_ = 0; + + if (!iEvent.isRealData()) { + edm::Handle metColl; + bool found = iEvent.getByToken(genMETToken_, metColl); + if (found && metColl.isValid()) { + edm::LogInfo("GenMETBlock") << "Total # GenMETs: " << metColl->size(); + for (const reco::GenMET& v: *metColl) { + if (list_->size() == kMaxGenMET_) { + edm::LogInfo("GenMETBlock") << "Too many GenMET, fnGenMET = " << list_->size(); + break; + } + vhtm::GenMET genMet; + + // fill in all the vectors + genMet.met = v.pt(); + genMet.metphi = v.phi(); + genMet.sumet = v.sumEt(); + + list_->push_back(genMet); + } + fnGenMET_ = list_->size(); + } + else { + edm::LogError("GenMETBlock") << "Error >> Failed to get GenMETCollection for label: " + << genMETTag_; + } + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(GenMETBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/GenMETBlock.h b/AnalysisSpace/TreeMaker/plugins/GenMETBlock.h new file mode 100644 index 0000000..851a3cf --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/GenMETBlock.h @@ -0,0 +1,44 @@ +#ifndef __AnalysisSpace_TreeMaker_GenMETBlock_h +#define __AnalysisSpace_TreeMaker_GenMETBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" + +namespace { + class GenMET; +} + +class GenMETBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit GenMETBlock(const edm::ParameterSet& iConfig); + virtual ~GenMETBlock() {} + + enum { + kMaxGenMET_ = 5 + }; + +private: + std::vector* list_; + int fnGenMET_; + + const int verbosity_; + const edm::InputTag genMETTag_; + const edm::EDGetTokenT genMETToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.cc new file mode 100644 index 0000000..7388860 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.cc @@ -0,0 +1,144 @@ +#include +#include +#include +#include + +#include "TTree.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/GenParticleBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +using namespace std; + +GenParticleBlock::GenParticleBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + genParticleTag_(iConfig.getUntrackedParameter("genParticleSrc", edm::InputTag("genParticles"))), + genParticleToken_(consumes(genParticleTag_)) +{ +} +GenParticleBlock::~GenParticleBlock() { +} +void GenParticleBlock::beginJob() { + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("GenParticle", "std::vector", &list_, 32000, 2); + tree->Branch("nGenParticle", &fnGenParticle_, "fnGenParticle_/I"); +} +void GenParticleBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnGenParticle_ = 0; + + if (!iEvent.isRealData()) { + edm::Handle genParticles; + bool found = iEvent.getByToken(genParticleToken_, genParticles); + if (found && genParticles.isValid()) { + edm::LogInfo("GenParticleBlock") << "Total # GenParticles: " << genParticles->size(); + if (verbosity_ > 0) { + std::cout << std::setprecision(2); + std::cout << "indx status pdgId charge eta phi pt energy mID dID" + << std::endl; + } + // for (const reco:;GenParticle& v:auto it = genParticles->begin(); it != genParticles->end(); ++it) { + for (const reco::GenParticle& v: *genParticles) { + if (list_->size() == kMaxGenParticle_) { + edm::LogInfo("GenParticleBlock") << "Too many GenParticles, fnGenParticle = " + << list_->size(); + break; + } + int pdgid = v.pdgId(); + double pt = v.pt(); + + vhtm::GenParticle gp; + + // fill in all the vectors + gp.eta = v.eta(); + gp.phi = v.phi(); + gp.p = v.p(); + gp.px = v.px(); + gp.py = v.py(); + gp.pz = v.pz(); + gp.pt = pt; + gp.energy = v.energy(); + gp.pdgId = pdgid; + gp.vx = v.vx(); + gp.vy = v.vy(); + gp.vz = v.vz(); + gp.status = v.status(); + gp.charge = v.charge(); + gp.numDaught = v.numberOfDaughters(); + gp.numMother = v.numberOfMothers(); + + // First mother + int idx = -1; + for (auto mit = genParticles->begin(); mit != genParticles->end(); ++mit) { + if (v.mother() == &(*mit)) { + idx = std::distance(genParticles->begin(), mit); + break; + } + } + gp.motherIndex = idx; + + // Mothers + ostringstream mID; + for (size_t j = 0; j < v.numberOfMothers(); ++j) { + const reco::Candidate* m = v.mother(j); + for (auto mit = genParticles->begin(); mit != genParticles->end(); ++mit) { + if (m == &(*mit) ) { + int idx = std::distance(genParticles->begin(), mit); + gp.motherIndices.push_back(idx); + mID << " " << idx; + break; + } + } + } + + // Daughters + ostringstream dID; + for (size_t j = 0; j < v.numberOfDaughters(); ++j) { + const reco::Candidate* d = v.daughter(j); + for (auto mit = genParticles->begin(); mit != genParticles->end(); ++mit) { + if (d == &(*mit) ) { + int idx = std::distance(genParticles->begin(), mit); + gp.daughtIndices.push_back(idx); + dID << " " << idx; + break; + } + } + } + + // Dump + if (verbosity_ > 0) { + string ms = mID.str(); + if (!ms.length()) ms = " -"; + + string ds = dID.str(); + if (!ds.length()) ds = " -"; + + std::cout << setw(4) << fnGenParticle_++ + << setw(8) << v.status() + << setw(10) << v.pdgId() + << setw(8) << v.charge() + << setw(10) << v.eta() + << setw(9) << v.phi() + << setw(9) << v.pt() + << setw(9) << v.energy() + << setw(16) << ms + << ds + << std::endl; + } + // add particle to the list + list_->push_back(gp); + } + fnGenParticle_ = list_->size(); + } + else { + edm::LogError("GenParticleBlock") << "Error >> Failed to get GenParticleCollection for label: " + << genParticleTag_; + } + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(GenParticleBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.h b/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.h new file mode 100644 index 0000000..d09e631 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.h @@ -0,0 +1,42 @@ +#ifndef __AnalysisSpace_TreeMaker_GenParticleBlock_h +#define __AnalysisSpace_TreeMaker_GenParticleBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +#include "DataFormats/HepMCCandidate/interface/GenParticle.h" + +namespace vhtm { + class GenParticle; +} +class GenParticleBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit GenParticleBlock(const edm::ParameterSet& iConfig); + virtual ~GenParticleBlock(); + + enum { + kMaxGenParticle_ = 2500 + }; + +private: + std::vector* list_; + int fnGenParticle_; + + const int verbosity_; + const edm::InputTag genParticleTag_; + const edm::EDGetTokenT genParticleToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.cc b/AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.cc new file mode 100644 index 0000000..fc51540 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.cc @@ -0,0 +1,156 @@ +#include + +#include "FWCore/Common/interface/TriggerNames.h" +#include "FWCore/Common/interface/TriggerResultsByName.h" +#include "AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.h" + +using namespace std; +using namespace edm; + +HLTEventAnalyzer::HLTEventAnalyzer(const edm::ParameterSet& ps) : + processName_(ps.getParameter("processName")), + triggerName_(ps.getParameter("triggerName")), + triggerResultsTag_(ps.getParameter("triggerResults")), + triggerEventTag_(ps.getParameter("triggerEvent")) +{ + _srcTriggerResultsToken = consumes(triggerResultsTag_); + _srcTriggerEventToken = consumes(triggerEventTag_); + + cout << "HLTEventAnalyzer configuration: " << endl + << " ProcessName = " << processName_ << endl + << " TriggerName = " << triggerName_ << endl + << " TriggerResultsTag = " << triggerResultsTag_.encode() << endl + << " TriggerEventTag = " << triggerEventTag_.encode() << endl; + +} +HLTEventAnalyzer::~HLTEventAnalyzer() +{ +} + +void HLTEventAnalyzer::beginRun(edm::Run const & iRun, edm::EventSetup const& iSetup) +{ + bool changed(true); + if (hltConfig_.init(iRun,iSetup,processName_,changed)) { + if (changed) { + // check if trigger name in (new) config + if (triggerName_!="@") { // "@" means: analyze all triggers in config + const unsigned int n(hltConfig_.size()); + const unsigned int triggerIndex(hltConfig_.triggerIndex(triggerName_)); + if (triggerIndex>=n) { + cout << "HLTEventAnalyzer::analyze:" + << " TriggerName " << triggerName_ + << " not available in (new) config!" << endl; + cout << "Available TriggerNames are: " << endl; + hltConfig_.dump("Triggers"); + } + } + hltConfig_.dump("ProcessName"); + hltConfig_.dump("GlobalTag"); + hltConfig_.dump("TableName"); + hltConfig_.dump("Streams"); + hltConfig_.dump("Datasets"); + hltConfig_.dump("PrescaleTable"); + hltConfig_.dump("ProcessPSet"); + } + } + else { + cout << "HLTEventAnalyzer::analyze:" + << " config extraction failure with process name " + << processName_ << endl; + } +} +void HLTEventAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + cout << endl; + + // get event products + iEvent.getByToken(_srcTriggerResultsToken, triggerResultsHandle_); + if (!triggerResultsHandle_.isValid()) { + cout << "HLTEventAnalyzer::analyze: Error in getting TriggerResults product from Event!" << endl; + return; + } + iEvent.getByToken(_srcTriggerEventToken, triggerEventHandle_); + if (!triggerEventHandle_.isValid()) { + cout << "HLTEventAnalyzer::analyze: Error in getting TriggerEvent product from Event!" << endl; + return; + } + // sanity check + assert(triggerResultsHandle_->size() == hltConfig_.size()); + + // analyze this event for the triggers requested + if (triggerName_== "@") { + const unsigned int n(hltConfig_.size()); + for (unsigned int i = 0; i != n; ++i) { + analyzeTrigger(iEvent, iSetup, hltConfig_.triggerName(i)); + } + } + else { + analyzeTrigger(iEvent, iSetup, triggerName_); + } +} + +void HLTEventAnalyzer::analyzeTrigger(const edm::Event& iEvent, const edm::EventSetup& iSetup, const std::string& triggerName) { + using namespace reco; + using namespace trigger; + + cout << endl; + + const unsigned int n(hltConfig_.size()); + const unsigned int triggerIndex(hltConfig_.triggerIndex(triggerName)); + assert(triggerIndex == iEvent.triggerNames(*triggerResultsHandle_).triggerIndex(triggerName)); + + // abort on invalid trigger name + if (triggerIndex >= n) { + cout << "HLTEventAnalyzer::analyzeTrigger: path " + << triggerName << " - not found!" << endl; + return; + } + + const std::pair prescales(hltConfig_.prescaleValues(iEvent,iSetup,triggerName)); + cout << "HLTEventAnalyzer::analyzeTrigger: path " + << triggerName << " [" << triggerIndex << "] " + << "prescales L1T,HLT: " << prescales.first << "," << prescales.second + << endl; + + // modules on this trigger path + const unsigned int m(hltConfig_.size(triggerIndex)); + const vector& moduleLabels(hltConfig_.moduleLabels(triggerIndex)); + // Results from TriggerResults product + cout << " Trigger path status:" + << " WasRun=" << triggerResultsHandle_->wasrun(triggerIndex) + << " Accept=" << triggerResultsHandle_->accept(triggerIndex) + << " Error =" << triggerResultsHandle_->error(triggerIndex) + << endl; + const unsigned int moduleIndex(triggerResultsHandle_->index(triggerIndex)); + cout << " Last active module - label/type: " + << moduleLabels[moduleIndex] << "/" << hltConfig_.moduleType(moduleLabels[moduleIndex]) + << " [" << moduleIndex << " out of 0-" << (m-1) << " on this path]" + << endl; + assert (moduleIndex < m); + + // Results from TriggerEvent product - Attention: must look only for + // modules actually run in this path for this event! + for (unsigned int j = 0; j <= moduleIndex; ++j) { + const string& moduleLabel(moduleLabels[j]); + const string moduleType(hltConfig_.moduleType(moduleLabel)); + // check whether the module is packed up in TriggerEvent product + const unsigned int filterIndex(triggerEventHandle_->filterIndex(InputTag(moduleLabel,"",processName_))); + if (filterIndexsizeFilters()) { + cout << " 'L3' filter in slot " << j << " - label/type " << moduleLabel << "/" << moduleType << endl; + const Vids& VIDS (triggerEventHandle_->filterIds(filterIndex)); + const Keys& KEYS(triggerEventHandle_->filterKeys(filterIndex)); + const size_type nI(VIDS.size()); + const size_type nK(KEYS.size()); + assert(nI==nK); + const size_type n(max(nI,nK)); + cout << " " << n << " accepted 'L3' objects found: " << endl; + const TriggerObjectCollection& TOC(triggerEventHandle_->getObjects()); + for (size_type i = 0; i != n; ++i) { + const TriggerObject& TO(TOC[KEYS[i]]); + cout << " " << i << " " << VIDS[i] << "/" << KEYS[i] << ": " + << TO.id() << " " << TO.pt() << " " << TO.eta() << " " << TO.phi() << " " << TO.mass() + << endl; + } + } + } +} diff --git a/AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.h b/AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.h new file mode 100644 index 0000000..4ad1f70 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/HLTEventAnalyzer.h @@ -0,0 +1,36 @@ +#ifndef AnalysisSpace_TreeMaker_HLTEventAnalyzerAOD_h +#define AnalysisSpace_TreeMaker_HLTEventAnalyzerAOD_h + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h" +#include "DataFormats/Common/interface/TriggerResults.h" +#include "DataFormats/HLTReco/interface/TriggerEvent.h" + +class HLTEventAnalyzer : public edm::EDAnalyzer { +public: + explicit HLTEventAnalyzer(const edm::ParameterSet&); + ~HLTEventAnalyzer(); + + virtual void beginRun(edm::Run const &, edm::EventSetup const&); + virtual void analyze(const edm::Event&, const edm::EventSetup&); + virtual void analyzeTrigger(const edm::Event&, const edm::EventSetup&, const std::string& triggerName); + +private: + + /// module config parameters + std::string processName_; + std::string triggerName_; + edm::InputTag triggerResultsTag_; + edm::InputTag triggerEventTag_; + + /// additional class data memebers + edm::Handle triggerResultsHandle_; + edm::Handle triggerEventHandle_; + HLTConfigProvider hltConfig_; + + edm::EDGetTokenT _srcTriggerResultsToken; + edm::EDGetTokenT _srcTriggerEventToken; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/JetBlock.cc b/AnalysisSpace/TreeMaker/plugins/JetBlock.cc new file mode 100644 index 0000000..9e24df2 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/JetBlock.cc @@ -0,0 +1,109 @@ +#include +#include + +#include "TTree.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "DataFormats/Common/interface/ValueMap.h" +#include "PhysicsTools/SelectorUtils/interface/PFJetIDSelectionFunctor.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/JetBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +PFJetIDSelectionFunctor pfjetIDLoose(PFJetIDSelectionFunctor::FIRSTDATA, PFJetIDSelectionFunctor::LOOSE); +PFJetIDSelectionFunctor pfjetIDTight(PFJetIDSelectionFunctor::FIRSTDATA, PFJetIDSelectionFunctor::TIGHT); +pat::strbitset retpf = pfjetIDLoose.getBitTemplate(); + +// Constructor +JetBlock::JetBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + jetTag_(iConfig.getUntrackedParameter("jetSrc", edm::InputTag("selectedPatJets"))), + jetToken_(consumes(jetTag_)) +{} +void JetBlock::beginJob() +{ + std::string tree_name = "vhtree"; + TTree* tree = vhtm::Utility::getTree(tree_name); + list_ = new std::vector(); + tree->Branch("Jet", "std::vector", &list_, 32000, 2); + tree->Branch("nJet", &fnJet_, "fnJet_/I"); +} +void JetBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnJet_ = 0; + + edm::Handle jets; + bool found = iEvent.getByToken(jetToken_, jets); + + if (found && jets.isValid()) { + unsigned int njets = jets->size(); + edm::LogInfo("JetBlock") << "Total # PAT Jets: " << njets; + for (const pat::Jet& jet: *jets) { + if (list_->size() == kMaxJet_) { + edm::LogInfo("JetBlock") << "Too many PAT Jets, fnJet = " << list_->size(); + break; + } + retpf.set(false); + int passjetLoose = (pfjetIDLoose(jet, retpf)) ? 1 : 0; + + retpf.set(false); + int passjetTight = (pfjetIDTight(jet, retpf)) ? 1 : 0; + + vhtm::Jet jobj; + + // fill in all the vectors + jobj.eta = jet.eta(); + jobj.phi = jet.phi(); + jobj.pt = jet.pt(); + jobj.pt_raw = jet.correctedJet("Uncorrected").pt(); + jobj.energy = jet.energy(); + jobj.energy_raw = jet.correctedJet("Uncorrected").energy(); + jobj.partonFlavour = jet.partonFlavour(); + + jobj.chargedEmEnergyFraction = jet.chargedEmEnergyFraction(); + jobj.chargedHadronEnergyFraction = jet.chargedHadronEnergyFraction(); + jobj.chargedMuEnergyFraction = jet.chargedMuEnergyFraction(); + jobj.electronEnergyFraction = jet.electronEnergy()/jet.energy(); + jobj.muonEnergyFraction = jet.muonEnergyFraction(); + jobj.neutralEmEnergyFraction = jet.neutralEmEnergyFraction(); + jobj.neutralHadronEnergyFraction = jet.neutralHadronEnergyFraction(); + jobj.photonEnergyFraction = jet.photonEnergyFraction(); + + jobj.chargedHadronMultiplicity = jet.chargedHadronMultiplicity(); + jobj.chargedMultiplicity = jet.chargedMultiplicity(); + jobj.electronMultiplicity = jet.electronMultiplicity(); + jobj.muonMultiplicity = jet.muonMultiplicity(); + jobj.neutralHadronMultiplicity = jet.neutralHadronMultiplicity(); + jobj.neutralMultiplicity = jet.neutralMultiplicity(); + jobj.photonMultiplicity = jet.photonMultiplicity(); + + jobj.nConstituents = jet.numberOfDaughters(); + + //jobj.simpleSecondaryVertexHighEffBTag = jet.bDiscriminator("simpleSecondaryVertexHighEffBJetTags"); + //jobj.simpleSecondaryVertexHighPurBTag = jet.bDiscriminator("simpleSecondaryVertexHighPurBJetTags"); + + jobj.combinedSecondaryVertexBTag = jet.bDiscriminator("combinedSecondaryVertexBJetTags"); + //jobj.combinedSecondaryVertexMVABTag = jet.bDiscriminator("combinedSecondaryVertexMVABJetTags"); + jobj.combinedInclusiveSecondaryVertexBTag + = jet.bDiscriminator("combinedInclusiveSecondaryVertexBJetTags"); + //jobj.combinedMVABTag = jet.bDiscriminator("combinedMVABJetTags"); + + jobj.passLooseID = passjetLoose; + jobj.passTightID = passjetTight; + + for (const std::pair& pa: jet.getPairDiscri()) + jobj.discrimap[pa.first] = pa.second; + + list_->push_back(jobj); + } + fnJet_ = list_->size(); + } + else { + edm::LogError("JetBlock") << "Error >> Failed to get pat::Jet collection for label: " + << jetTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(JetBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/JetBlock.h b/AnalysisSpace/TreeMaker/plugins/JetBlock.h new file mode 100644 index 0000000..cbd55ea --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/JetBlock.h @@ -0,0 +1,46 @@ +#ifndef __VHTauTau_TreeMaker_JetBlock_h +#define __VHTauTau_TreeMaker_JetBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/Common/interface/Ref.h" + +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Provenance/interface/EventID.h" +#include "FWCore/ParameterSet/interface/ProcessDesc.h" +#include "DataFormats/PatCandidates/interface/Jet.h" + +namespace vhtm { + class Jet; +} +class JetBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit JetBlock(const edm::ParameterSet& iConfig); + virtual ~JetBlock() {} + + enum { + kMaxJet_ = 100 + }; +private: + std::vector* list_; + int fnJet_; + + const int verbosity_; + const edm::InputTag jetTag_; + const edm::EDGetTokenT jetToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/METBlock.cc b/AnalysisSpace/TreeMaker/plugins/METBlock.cc new file mode 100644 index 0000000..979ebdd --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/METBlock.cc @@ -0,0 +1,85 @@ +#include "TTree.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/METBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +METBlock::METBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + pfMETTag_(iConfig.getUntrackedParameter("metSrc", edm::InputTag("patMETs"))), + corrMETTag_(iConfig.getUntrackedParameter("corrmetSrc", edm::InputTag("patMETsTypeIcorrected"))), + mvaMETTag_(iConfig.getUntrackedParameter("mvametSrc", edm::InputTag("patPFMetByMVA"))), + pfMETToken_(consumes(pfMETTag_)), + corrMETToken_(consumes(corrMETTag_)), + mvaMETToken_(consumes(mvaMETTag_)) +{ +} +void METBlock::beginJob() +{ + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + + pfList_ = new std::vector(); + tree->Branch("MET", "std::vector", &pfList_, 32000, 2); + tree->Branch("nMET", &fnPFMET_, "fnPFMET_/I"); + +#if 0 + corrList_ = new std::vector(); + tree->Branch("corrMET", "std::vector", &corrList_, 32000, 2); + tree->Branch("corrnMET", &fnCorrMET_, "fnCorrMET_/I"); + + mvaList_ = new std::vector(); + tree->Branch("mvaMET", "std::vector", &mvaList_, 32000, 2); + tree->Branch("mvanMET", &fnMVAMET_, "fnMVAMET_/I"); +#endif +} +void METBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + fillMET(iEvent, iSetup, pfList_, fnPFMET_, pfMETTag_, pfMETToken_); + //fillMET(iEvent, iSetup, corrList_, fnCorrMET_, corrMETTag_, corrMETToken_); + //fillMET(iEvent, iSetup, mvaList_, fnMVAMET_, mvaMETTag_, mvaMETToken_); +} +void METBlock::fillMET(const edm::Event& iEvent, + const edm::EventSetup& iSetup, + std::vector* list, + int& nMET, + const edm::InputTag& iTag, + const edm::EDGetTokenT& token) +{ + // Reset the TClonesArray and the nObj variables + list->clear(); + nMET = 0; + + edm::Handle metColl; + bool found = iEvent.getByToken(token, metColl); + + if (found && metColl.isValid()) { + edm::LogInfo("METBlock") << "Total # PAT METs: " << metColl->size(); + for (const pat::MET& v: *metColl) { + if (list->size() == kMaxMET_) { + edm::LogInfo("METBlock") << "Too many PAT MET, nMET = " << list->size() + << ", label: " << iTag; + break; + } + vhtm::MET mobj; + // fill in all the vectors + mobj.met = v.pt(); + mobj.metphi = v.phi(); + mobj.sumet = v.sumEt(); + mobj.metuncorr = v.uncorrectedPt(pat::MET::uncorrALL); + mobj.metphiuncorr = v.uncorrectedPhi(pat::MET::uncorrALL); + mobj.sumetuncorr = v.sumEt() - v.corSumEt(pat::MET::uncorrALL); + + list->push_back(mobj); + } + nMET = list->size(); + } + else { + edm::LogError("METBlock") << "Error! Failed to get pat::MET collection for label: " + << iTag; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(METBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/METBlock.h b/AnalysisSpace/TreeMaker/plugins/METBlock.h new file mode 100644 index 0000000..a07b081 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/METBlock.h @@ -0,0 +1,59 @@ +#ifndef __AnalysisSpace_TreeMaker_METBlock_h +#define __AnalysisSpace_TreeMaker_METBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/PatCandidates/interface/MET.h" + +namespace vhtm { + class MET; +} +class METBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit METBlock(const edm::ParameterSet& iConfig); + virtual ~METBlock() {} + + enum { + kMaxMET_ = 5 + }; + + void fillMET(const edm::Event& iEvent, + const edm::EventSetup& iSetup, + std::vector* list, + int& fnMET, + const edm::InputTag& iTag, + const edm::EDGetTokenT& token); + +private: + std::vector* pfList_; + int fnPFMET_; + + std::vector* corrList_; + int fnCorrMET_; + + std::vector* mvaList_; + int fnMVAMET_; + + const int verbosity_; + const edm::InputTag pfMETTag_; + const edm::InputTag corrMETTag_; + const edm::InputTag mvaMETTag_; + + const edm::EDGetTokenT pfMETToken_; + const edm::EDGetTokenT corrMETToken_; + const edm::EDGetTokenT mvaMETToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc new file mode 100644 index 0000000..5cd9cc1 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc @@ -0,0 +1,258 @@ +#include + +#include "TTree.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include "DataFormats/PatCandidates/interface/Muon.h" +#include "DataFormats/TrackReco/interface/HitPattern.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "Math/GenVector/VectorUtil.h" +#include "DataFormats/Math/interface/deltaR.h" + +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" +#include "DataFormats/GeometryVector/interface/VectorUtil.h" + +#include "DataFormats/MuonReco/interface/MuonIsolation.h" +#include "DataFormats/MuonReco/interface/MuonPFIsolation.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/MuonBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +MuonBlock::MuonBlock(const edm::ParameterSet& iConfig): + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + muonTag_(iConfig.getUntrackedParameter("muonSrc", edm::InputTag("selectedPatMuons"))), + vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), + bsTag_(iConfig.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), + pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), + bsCorr_(iConfig.getUntrackedParameter("beamSpotCorr", true)), + muonID_(iConfig.getUntrackedParameter("muonID", "GlobalMuonPromptTight")), + muonToken_(consumes(muonTag_)), + vertexToken_(consumes(vertexTag_)), + bsToken_(consumes(bsTag_)), + pfToken_(consumes(pfcandTag_)) +{ +} +MuonBlock::~MuonBlock() { +} +void MuonBlock::beginJob() +{ + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("Muon", "std::vector", &list_, 32000, 2); + tree->Branch("nMuon", &fnMuon_, "fnMuon_/I"); +} +void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnMuon_ = 0; + + edm::Handle muons; + bool found = iEvent.getByToken(muonToken_, muons); + + edm::Handle pfs; + iEvent.getByToken(pfToken_, pfs); + + if (found && muons.isValid()) { + edm::Handle primaryVertices; + iEvent.getByToken(vertexToken_, primaryVertices); + + edm::Handle beamSpot; + iEvent.getByToken(bsToken_, beamSpot); + + edm::LogInfo("MuonBlock") << "Total # of Muons: " << muons->size(); + for (const pat::Muon& v: *muons) { + if (list_->size() == kMaxMuon_) { + edm::LogInfo("MuonBlock") << "Too many PAT Muons, fnMuon = " << list_->size(); + break; + } + // consider only global muons + if (!v.isGlobalMuon()) continue; + reco::TrackRef tk = v.innerTrack(); // tracker segment only + reco::TrackRef gtk = v.globalTrack(); + + vhtm::Muon muon; + muon.isTrackerMuon = v.isTrackerMuon() ? true : false; + muon.isPFMuon = v.isPFMuon(); + + muon.eta = v.eta(); + muon.phi = v.phi(); + muon.pt = v.pt(); + muon.p = v.p(); + muon.energy = v.energy(); + muon.charge = v.charge(); + + double trkd0 = tk->d0(); + double trkdz = tk->dz(); + if (bsCorr_) { + if (beamSpot.isValid()) { + trkd0 = -(tk->dxy(beamSpot->position())); + trkdz = tk->dz(beamSpot->position()); + } + else + edm::LogError("MuonsBlock") << "Error >> Failed to get reco::BeamSpot for label: " + << bsTag_; + } + muon.trkD0 = trkd0; + muon.trkDz = trkdz; + muon.globalChi2 = v.normChi2(); + muon.passID = v.muonID(muonID_) ? true : false; + + double dxyWrtPV = -99.; + double dzWrtPV = -99.; + if (primaryVertices.isValid()) { + edm::LogInfo("MuonBlock") << "Total # Primary Vertices: " << primaryVertices->size(); + + const reco::Vertex& vit = primaryVertices->front(); // Highest sumPt vertex + dxyWrtPV = tk->dxy(vit.position()); + dzWrtPV = tk->dz(vit.position()); + muon.dxyPV = dxyWrtPV; + muon.dzPV = dzWrtPV; + + // Vertex association + double minVtxDist3D = 9999.; + int indexVtx = -1; + double vertexDistZ = 9999.; + for (auto vit = primaryVertices->begin(); vit != primaryVertices->end(); ++vit) { + double dxy = tk->dxy(vit->position()); + double dz = tk->dz(vit->position()); + double dist3D = std::sqrt(pow(dxy,2) + pow(dz,2)); + if (dist3D < minVtxDist3D) { + minVtxDist3D = dist3D; + indexVtx = static_cast(std::distance(primaryVertices->begin(), vit)); + vertexDistZ = dz; + } + } + muon.vtxDist3D = minVtxDist3D; + muon.vtxIndex = indexVtx; + muon.vtxDistZ = vertexDistZ; + } + else { + edm::LogError("MuonBlock") << "Error >> Failed to get reco::VertexCollection for label: " + << vertexTag_; + } + // Hit pattern + const reco::HitPattern& hitp = gtk->hitPattern(); // innerTrack will not provide Muon Hits + muon.pixHits = hitp.numberOfValidPixelHits(); + muon.trkHits = hitp.numberOfValidTrackerHits(); + muon.muoHits = hitp.numberOfValidMuonHits(); + muon.matches = v.numberOfMatches(); + muon.trackerLayersWithMeasurement = hitp.trackerLayersWithMeasurement(); + + int numMuonStations = 0; + unsigned int stationMask = static_cast(v.stationMask(reco::Muon::SegmentAndTrackArbitration)); + for (int i = 0; i < 8; ++i) // eight stations, eight bits + if (stationMask & (1<normalizedChi2(); + double ptError = v.innerTrack()->ptError()/v.innerTrack()->pt(); + + bool muonID = v.isGlobalMuon() && + v.isTrackerMuon() && + muon.isGlobalMuonPromptTight && + muon.isAllArbitrated && + std::fabs(dxyWrtPV) < 0.02 && + std::fabs(dzWrtPV) < 0.2 && + normalizeChi2 < 10 && + ptError < 0.1 && + muon.trkHits >= 10 && + muon.pixHits >= 1 && + numMuonStations >= 2 && + muon.nMatches >= 1; + muon.muonID = muonID; + + // Vertex information + const reco::Candidate::Point& vertex = v.vertex(); + muon.vx = vertex.x(); + muon.vy = vertex.y(); + muon.vz = vertex.z(); + + //Isolation from packed PF candidates + + std::vector isotemp; + for( double cone=0.15;cone<=0.4;cone+=0.05){ + isotemp.clear(); + calcIsoFromPF(cone, pfs, v, isotemp); + muon.isolationMap[cone] = isotemp; + } + list_->push_back(muon); + } + fnMuon_ = list_->size(); + } + else { + edm::LogError("MuonBlock") << "Error >> Failed to get pat::Muon collection for label: " + << muonTag_; + } +} + +void MuonBlock::calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Muon& v, std::vector& iso) +{ + // initialize sums + double charged = 0, neutral = 0, pileup = 0; + // now get a list of the PF candidates used to build this lepton, so to exclude them + std::vector footprint; + for (unsigned int i = 0, n = v.numberOfSourceCandidatePtrs(); i < n; ++i) { + footprint.push_back(v.sourceCandidatePtr(i)); + } + // now loop on pf candidates + for (unsigned int i = 0, n = pfs->size(); i < n; ++i) { + const pat::PackedCandidate &pf = (*pfs)[i]; + if (deltaR(pf,v) < cone) { + //pfcandidate-based footprint removal + if (std::find(footprint.begin(), footprint.end(), reco::CandidatePtr(pfs,i)) != footprint.end()) { + continue; + } + if (pf.charge() == 0) { + if (pf.pt() > 0.5) neutral += pf.pt(); + } else if (pf.fromPV() >= 2) { + charged += pf.pt(); + } else { + if (pf.pt() > 0.5) pileup += pf.pt(); + } + } + } + iso.push_back(charged); + iso.push_back(neutral); + iso.push_back(pileup); +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(MuonBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ new file mode 100644 index 0000000..ea2adf3 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ @@ -0,0 +1,255 @@ +#include + +#include "TTree.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include "DataFormats/PatCandidates/interface/Muon.h" +#include "DataFormats/TrackReco/interface/HitPattern.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "Math/GenVector/VectorUtil.h" +#include "DataFormats/Math/interface/deltaR.h" + +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" +#include "DataFormats/GeometryVector/interface/VectorUtil.h" + +#include "DataFormats/MuonReco/interface/MuonIsolation.h" +#include "DataFormats/MuonReco/interface/MuonPFIsolation.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/MuonBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +MuonBlock::MuonBlock(const edm::ParameterSet& iConfig): + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + muonTag_(iConfig.getUntrackedParameter("muonSrc", edm::InputTag("selectedPatMuons"))), + vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), + bsTag_(iConfig.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), + pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), + bsCorr_(iConfig.getUntrackedParameter("beamSpotCorr", true)), + muonID_(iConfig.getUntrackedParameter("muonID", "GlobalMuonPromptTight")), + muonToken_(consumes(muonTag_)), + vertexToken_(consumes(vertexTag_)), + bsToken_(consumes(bsTag_)), + pfToken_(consumes(pfcandTag_)) +{ +} +MuonBlock::~MuonBlock() { +} +void MuonBlock::beginJob() +{ + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("Muon", "std::vector", &list_, 32000, 2); + tree->Branch("nMuon", &fnMuon_, "fnMuon_/I"); +} +void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnMuon_ = 0; + + edm::Handle muons; + bool found = iEvent.getByToken(muonToken_, muons); + + edm::Handle pfs; + iEvent.getByToken(pfToken_, pfs); + + if (found && muons.isValid()) { + edm::Handle primaryVertices; + iEvent.getByToken(vertexToken_, primaryVertices); + + edm::Handle beamSpot; + iEvent.getByToken(bsToken_, beamSpot); + + edm::LogInfo("MuonBlock") << "Total # of Muons: " << muons->size(); + for (const pat::Muon& v: *muons) { + if (list_->size() == kMaxMuon_) { + edm::LogInfo("MuonBlock") << "Too many PAT Muons, fnMuon = " << list_->size(); + break; + } + // consider only global muons + if (!v.isGlobalMuon()) continue; + reco::TrackRef tk = v.innerTrack(); // tracker segment only + reco::TrackRef gtk = v.globalTrack(); + + vhtm::Muon muon; + muon.isTrackerMuon = v.isTrackerMuon() ? true : false; + muon.isPFMuon = v.isPFMuon(); + + muon.eta = v.eta(); + muon.phi = v.phi(); + muon.pt = v.pt(); + muon.p = v.p(); + muon.energy = v.energy(); + muon.charge = v.charge(); + + double trkd0 = tk->d0(); + double trkdz = tk->dz(); + if (bsCorr_) { + if (beamSpot.isValid()) { + trkd0 = -(tk->dxy(beamSpot->position())); + trkdz = tk->dz(beamSpot->position()); + } + else + edm::LogError("MuonsBlock") << "Error >> Failed to get reco::BeamSpot for label: " + << bsTag_; + } + muon.trkD0 = trkd0; + muon.trkDz = trkdz; + muon.globalChi2 = v.normChi2(); + muon.passID = v.muonID(muonID_) ? true : false; + + double dxyWrtPV = -99.; + double dzWrtPV = -99.; + if (primaryVertices.isValid()) { + edm::LogInfo("MuonBlock") << "Total # Primary Vertices: " << primaryVertices->size(); + + const reco::Vertex& vit = primaryVertices->front(); // Highest sumPt vertex + dxyWrtPV = tk->dxy(vit.position()); + dzWrtPV = tk->dz(vit.position()); + muon.dxyPV = dxyWrtPV; + muon.dzPV = dzWrtPV; + + // Vertex association + double minVtxDist3D = 9999.; + int indexVtx = -1; + double vertexDistZ = 9999.; + for (auto vit = primaryVertices->begin(); vit != primaryVertices->end(); ++vit) { + double dxy = tk->dxy(vit->position()); + double dz = tk->dz(vit->position()); + double dist3D = std::sqrt(pow(dxy,2) + pow(dz,2)); + if (dist3D < minVtxDist3D) { + minVtxDist3D = dist3D; + indexVtx = static_cast(std::distance(primaryVertices->begin(), vit)); + vertexDistZ = dz; + } + } + muon.vtxDist3D = minVtxDist3D; + muon.vtxIndex = indexVtx; + muon.vtxDistZ = vertexDistZ; + } + else { + edm::LogError("MuonBlock") << "Error >> Failed to get reco::VertexCollection for label: " + << vertexTag_; + } + // Hit pattern + const reco::HitPattern& hitp = gtk->hitPattern(); // innerTrack will not provide Muon Hits + muon.pixHits = hitp.numberOfValidPixelHits(); + muon.trkHits = hitp.numberOfValidTrackerHits(); + muon.muoHits = hitp.numberOfValidMuonHits(); + muon.matches = v.numberOfMatches(); + muon.trackerLayersWithMeasurement = hitp.trackerLayersWithMeasurement(); + + int numMuonStations = 0; + unsigned int stationMask = static_cast(v.stationMask(reco::Muon::SegmentAndTrackArbitration)); + for (int i = 0; i < 8; ++i) // eight stations, eight bits + if (stationMask & (1<normalizedChi2(); + double ptError = v.innerTrack()->ptError()/v.innerTrack()->pt(); + + bool muonID = v.isGlobalMuon() && + v.isTrackerMuon() && + muon.isGlobalMuonPromptTight && + muon.isAllArbitrated && + std::fabs(dxyWrtPV) < 0.02 && + std::fabs(dzWrtPV) < 0.2 && + normalizeChi2 < 10 && + ptError < 0.1 && + muon.trkHits >= 10 && + muon.pixHits >= 1 && + numMuonStations >= 2 && + muon.nMatches >= 1; + muon.muonID = muonID; + + // Vertex information + const reco::Candidate::Point& vertex = v.vertex(); + muon.vx = vertex.x(); + muon.vy = vertex.y(); + muon.vz = vertex.z(); + + //Isolation from packed PF candidates + std::vector isotemp; + calcIsoFromPF(0.2,pfs,v,isotemp); + isolationMap[0.2]=isotemp; + + list_->push_back(muon); + } + fnMuon_ = list_->size(); + } + else { + edm::LogError("MuonBlock") << "Error >> Failed to get pat::Muon collection for label: " + << muonTag_; + } +} + +void MuonBlock::calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Muon& v, std::vector& iso) +{ + // initialize sums + double charged = 0, neutral = 0, pileup = 0; + // now get a list of the PF candidates used to build this lepton, so to exclude them + std::vector footprint; + for (unsigned int i = 0, n = v.numberOfSourceCandidatePtrs(); i < n; ++i) { + footprint.push_back(v.sourceCandidatePtr(i)); + } + // now loop on pf candidates + for (unsigned int i = 0, n = pfs->size(); i < n; ++i) { + const pat::PackedCandidate &pf = (*pfs)[i]; + if (deltaR(pf,v) < cone) { + //pfcandidate-based footprint removal + if (std::find(footprint.begin(), footprint.end(), reco::CandidatePtr(pfs,i)) != footprint.end()) { + continue; + } + if (pf.charge() == 0) { + if (pf.pt() > 0.5) neutral += pf.pt(); + } else if (pf.fromPV() >= 2) { + charged += pf.pt(); + } else { + if (pf.pt() > 0.5) pileup += pf.pt(); + } + } + } + iso.push_back(charged); + iso.push_back(neutral); + iso.push_back(pileup); +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(MuonBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.h b/AnalysisSpace/TreeMaker/plugins/MuonBlock.h new file mode 100644 index 0000000..7b4743f --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.h @@ -0,0 +1,51 @@ +#ifndef __AnalysisSpace_TreeMaker_MuonBlock_h +#define __AnalysisSpace_TreeMaker_MuonBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +namespace vhtm { + class Muon; +} +class MuonBlock : public edm::EDAnalyzer +{ + private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob(){} + void calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Muon& v, std::vector& iso); + public: + explicit MuonBlock(const edm::ParameterSet& iConfig); + virtual ~MuonBlock(); + + enum { + kMaxMuon_ = 100 + }; + + private: + std::vector* list_; + int fnMuon_; + + const int verbosity_; + + const edm::InputTag muonTag_; + const edm::InputTag vertexTag_; + const edm::InputTag bsTag_; + const edm::InputTag pfcandTag_; + + const bool bsCorr_; + const std::string muonID_; + + const edm::EDGetTokenT muonToken_; + const edm::EDGetTokenT vertexToken_; + const edm::EDGetTokenT bsToken_; + const edm::EDGetTokenT pfToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ new file mode 100644 index 0000000..52462c6 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ @@ -0,0 +1,51 @@ +#ifndef __AnalysisSpace_TreeMaker_MuonBlock_h +#define __AnalysisSpace_TreeMaker_MuonBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +namespace vhtm { + class Muon; +} +class MuonBlock : public edm::EDAnalyzer +{ + private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob(){} + void calcIsoFromPF(double cone, const pat::PackedCandidateCollection pfs, const pat::Muon& v, std::vector& iso); + public: + explicit MuonBlock(const edm::ParameterSet& iConfig); + virtual ~MuonBlock(); + + enum { + kMaxMuon_ = 100 + }; + + private: + std::vector* list_; + int fnMuon_; + + const int verbosity_; + + const edm::InputTag muonTag_; + const edm::InputTag vertexTag_; + const edm::InputTag bsTag_; + const edm::InputTag pfcandTag_; + + const bool bsCorr_; + const std::string muonID_; + + const edm::EDGetTokenT muonToken_; + const edm::EDGetTokenT vertexToken_; + const edm::EDGetTokenT bsToken_; + const edm::EDGetTokenT pfToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc new file mode 100644 index 0000000..126edc5 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc @@ -0,0 +1,172 @@ +#include +#include + +#include "TTree.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" + +#include "DataFormats/GeometryVector/interface/GlobalVector.h" +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/EgammaReco/interface/SuperCluster.h" +#include "DataFormats/EgammaCandidates/interface/Conversion.h" +#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h" + +#include "AnalysisSpace/TreeMaker/plugins/PhotonBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +// Constructor +PhotonBlock::PhotonBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + photonTag_(iConfig.getParameter("photonSrc")), + photonToken_(consumes(photonTag_)) +{} +void PhotonBlock::beginJob() +{ + // Get TTree pointer + std::string tree_name = "vhtree"; + TTree* tree = vhtm::Utility::getTree(tree_name); + list_ = new std::vector(); + tree->Branch("Photon", "std::vector", &list_, 32000, 2); + tree->Branch("nPhoton", &fnPhoton_, "fnPhoton_/I"); +} +void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the TClonesArray and the nObj variables + list_->clear(); + fnPhoton_ = 0; + + edm::Handle photons; + bool found = iEvent.getByToken(photonToken_, photons); + + if (found && photons.isValid()) { + edm::LogInfo("PhotonBlock") << "Total # PAT Photons: " << photons->size(); + for (pat::Photon const& v: *photons) { + if (list_->size() == kMaxPhoton) { + edm::LogInfo("PhotonBlock") << "Too many PAT Photon, fnPhoton = " + << fnPhoton_; + break; + } + vhtm::Photon photon; + photon.et = v.et(); + photon.eta = v.eta(); + photon.clusterEta = v.caloPosition().eta(); + photon.phi = v.phi(); + photon.clusterPhi = v.caloPosition().phi(); + photon.energy = v.energy(); + photon.theta = v.theta(); + photon.vx = v.vx(); + photon.vy = v.vy(); + photon.vz = v.vz(); + + const reco::SuperClusterRef sCluster = v.superCluster(); + photon.scEnergy = sCluster->energy(); + photon.scEta = sCluster->eta(); + photon.scPhi = sCluster->phi(); + photon.scSize = sCluster->clustersSize(); + photon.scEtaWidth = sCluster->etaWidth(); + photon.scPhiWidth = sCluster->phiWidth(); + photon.scEt = sCluster->energy()/cosh(sCluster->eta()); + photon.scRawEnergy = sCluster->rawEnergy(); + photon.scx = sCluster->x(); + photon.scy = sCluster->y(); + photon.scz = sCluster->z(); + + photon.isoEcalRecHit03 = v.ecalRecHitSumEtConeDR03(); + photon.isoHcalRecHit03 = v.hcalTowerSumEtConeDR03(); + photon.isoSolidTrkCone03 = v.trkSumPtSolidConeDR03(); + photon.isoHollowTrkCone03 = v.trkSumPtHollowConeDR03(); + photon.nTrkSolidCone03 = v.nTrkSolidConeDR03(); + photon.nTrkHollowCone03 = v.nTrkHollowConeDR03(); + + photon.isoEcalRecHit04 = v.ecalRecHitSumEtConeDR04(); + photon.isoHcalRecHit04 = v.hcalTowerSumEtConeDR04(); + photon.isoSolidTrkCone04 = v.trkSumPtSolidConeDR04(); + photon.isoHollowTrkCone04 = v.trkSumPtHollowConeDR04(); + photon.nTrkSolidCone04 = v.nTrkSolidConeDR04(); + photon.nTrkHollowCone04 = v.nTrkHollowConeDR04(); + + photon.hasPixelSeed = v.hasPixelSeed(); + photon.ecalIso = v.ecalIso(); + photon.hcalIso = v.hcalIso(); + photon.trackIso = v.trackIso(); + + photon.chargedHadIso = v.chargedHadronIso(); + photon.neutralHadIso = v.neutralHadronIso(); + photon.photonIso = v.photonIso(); + + int fidFlag = 0; + if (v.isEB()) fidFlag |= (1 << 0); + if (v.isEE()) fidFlag |= (1 << 1); + if (v.isEBEtaGap()) fidFlag |= (1 << 2); + if (v.isEBPhiGap()) fidFlag |= (1 << 3); + if (v.isEERingGap()) fidFlag |= (1 << 4); + if (v.isEEDeeGap()) fidFlag |= (1 << 5); + if (v.isEBEEGap()) fidFlag |= (1 << 6); + photon.fidFlag = fidFlag; + + photon.isEB = v.isEB() ? true : false; + photon.isEE = v.isEE() ? true : false; + photon.isEBGap = v.isEBGap() ? true : false ; + photon.isEEGap = v.isEEGap() ? true : false; + photon.isEBEEGap = v.isEBEEGap() ? true : false; + + photon.r9 = v.r9(); + photon.hoe = v.hadronicOverEm(); + photon.sigmaEtaEta = v.sigmaEtaEta(); + photon.sigmaIEtaIEta = v.sigmaIetaIeta(); + photon.e1x5 = v.e1x5(); + photon.e2x5 = v.e2x5(); + photon.e3x3 = v.e3x3(); + photon.e5x5 = v.e5x5(); + photon.r1x5 = v.r1x5(); + photon.r2x5 = v.r2x5(); + photon.maxEnergyXtal = v.maxEnergyXtal(); + + photon.hasConversionTracks = v.hasConversionTracks(); + if (v.hasConversionTracks()) { + const reco::ConversionRefVector conversions = v.conversions(); + for (edm::RefVector::const_iterator jt = conversions.begin(); + jt != conversions.end(); + ++jt) + { + const reco::Conversion& obj = (**jt); + if (obj.nTracks() < 2 or + !obj.conversionVertex().isValid()) continue; + photon.nTracks = obj.nTracks(); + photon.isConverted = obj.isConverted(); + photon.pairInvMass = obj.pairInvariantMass(); + photon.pairCotThetaSeparation + = obj.pairCotThetaSeparation(); + + math::XYZVectorF mom = obj.pairMomentum(); + photon.pairPx = mom.x(); + photon.pairPy = mom.y(); + photon.pairPz = mom.z(); + + const reco::Vertex &vertex = obj.conversionVertex(); + photon.conv_vx = vertex.x(); + photon.conv_vy = vertex.y(); + photon.conv_vz = vertex.z(); + + photon.eovp = obj.EoverP(); + photon.zpv = obj.zOfPrimaryVertexFromTracks(); + photon.distOfMinApproach = obj.distOfMinimumApproach(); + photon.dPhiTracksAtVtx = obj.dPhiTracksAtVtx(); + photon.dPhiTracksAtEcal = obj.dPhiTracksAtEcal(); + photon.dEtaTracksAtEcal = obj.dEtaTracksAtEcal(); + } + } + list_->push_back(photon); + } + fnPhoton_ = list_->size(); + } + else { + edm::LogError("PhotonBlock") << "Error >> Failed to get pat::Photon for label: " + << photonTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PhotonBlock); + diff --git a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h new file mode 100644 index 0000000..dca8761 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h @@ -0,0 +1,48 @@ +#ifndef __AnalysisSpace_TreeMaker_PhotonBlock_h +#define __AnalysisSpace_TreeMaker_PhotonBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/Common/interface/Ref.h" + +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Provenance/interface/EventID.h" +#include "FWCore/ParameterSet/interface/ProcessDesc.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" + +namespace vhtm { + class Photon; +} + +class PhotonBlock : public edm::EDAnalyzer +{ + private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + + public: + explicit PhotonBlock(const edm::ParameterSet& iConfig); + virtual ~PhotonBlock() {} + + enum { + kMaxPhoton = 100 + }; + private: + std::vector* list_; + int fnPhoton_; + + int verbosity_; + edm::InputTag photonTag_; + const edm::EDGetTokenT photonToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/TauBlock.cc b/AnalysisSpace/TreeMaker/plugins/TauBlock.cc new file mode 100644 index 0000000..59ee1ba --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TauBlock.cc @@ -0,0 +1,240 @@ +#include + +#include "TTree.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Common/interface/Ref.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "DataFormats/PatCandidates/interface/TauPFEssential.h" + +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "Utilities/General/interface/FileInPath.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/TauBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +namespace tb +{ + template + bool isValidRef(const edm::Ref& ref) { + return ( (ref.isAvailable() || ref.isTransient()) && ref.isNonnull() ); + } +} +TauBlock::TauBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + tauTag_(iConfig.getUntrackedParameter("patTauSrc", edm::InputTag("selectedPatTaus"))), + vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), + bsTag_(iConfig.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), + bsCorr_(iConfig.getUntrackedParameter("beamSpotCorr", true)), + tauToken_(consumes(tauTag_)), + vertexToken_(consumes(vertexTag_)), + bsToken_(consumes(bsTag_)) +{ +} +TauBlock::~TauBlock() {} +void TauBlock::beginJob() +{ + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("Tau", "std::vector", &list_, 32000, 2); + tree->Branch("nTau", &fnTau_, "fnTau_/I"); +} +void TauBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnTau_ = 0; + + edm::Handle taus; + bool found = iEvent.getByToken(tauToken_, taus); + + if (found && taus.isValid()) { + edm::Handle primaryVertices; + iEvent.getByToken(vertexToken_, primaryVertices); + + edm::Handle beamSpot; + if (bsCorr_) + iEvent.getByToken(bsToken_, beamSpot); + + edm::LogInfo("TauBlock") << "Total # PAT Taus: " << taus->size(); + for (const pat::Tau& v: *taus) { + if (list_->size() == kMaxTau_) { + edm::LogInfo("TauBlock") << "Too many PAT Taus, fnTau = " << list_->size(); + break; + } + vhtm::Tau tau; + + // Store Tau variables + tau.eta = v.eta(); + tau.phi = v.phi(); + tau.pt = v.pt(); + tau.energy = v.energy(); + tau.charge = v.charge(); + if (v.leadChargedHadrCand().isNonnull()) { + // We know that it returns a PackedCandidate + const pat::PackedCandidate& trk = dynamic_cast(*v.leadChargedHadrCand()); + + if (primaryVertices.isValid()) { + edm::LogInfo("TauBlock") << "Total # Primary Vertices: " + << primaryVertices->size(); + + // IP of leadChargedHadrCand wrt event PV + const reco::Vertex& vit = primaryVertices->front(); + tau.dxyPV = trk.dxy(vit.position()); + tau.dzPV = trk.dz(vit.position()); + + // IP of leadChargedHadrCand wrt closest PV + // Vertex association + double minVtxDist3D = 9999.; + int indexVtx = -1; + double vertexDz = 9999.; + double vertexDxy = 9999.; + for (auto vit = primaryVertices->begin(); vit != primaryVertices->end(); ++vit) { + double dxy = trk.dxy(vit->position()); + double dz = trk.dz(vit->position()); + double dist3D = std::sqrt(pow(dxy,2) + pow(dz,2)); + if (dist3D < minVtxDist3D) { + minVtxDist3D = dist3D; + indexVtx = int(std::distance(primaryVertices->begin(), vit)); + vertexDxy = dxy; + vertexDz = dz; + } + } + tau.vtxIndex = indexVtx; + tau.vtxDxy = vertexDxy; + tau.vtxDz = vertexDz; + } + else { + edm::LogError("TauBlock") << "Error >> Failed to get VertexCollection for label: " + << vertexTag_; + } + } + // Leading particle pT + tau.leadChargedParticlePt = + v.leadChargedHadrCand().isNonnull() ? v.leadChargedHadrCand()->pt(): 0.; + tau.leadNeutralParticlePt = + v.leadNeutralCand().isNonnull() ? v.leadNeutralCand()->et(): 0.; + tau.leadParticlePt = + v.leadCand().isNonnull() ? v.leadCand()->et(): 0.; + + // Signal Constituents + // Charged hadrons + for (const reco::CandidatePtr& iCand: v.signalChargedHadrCands()) { + const reco::Candidate& cand = (*iCand); + vhtm::Candidate c(cand.pt(), cand.eta(), cand.phi()); + tau.sigChHadList.push_back(c); + } + // Neutral hadrons + for (const reco::CandidatePtr& iCand: v.signalNeutrHadrCands()) { + const reco::Candidate& cand = (*iCand); + vhtm::Candidate c(cand.pt(), cand.eta(), cand.phi()); + tau.sigNeHadList.push_back(c); + } + // Photons + double sigPtSumGamma = 0; + for (const reco::CandidatePtr& iCand: v.signalGammaCands()) { + const reco::Candidate& cand = (*iCand); + vhtm::Candidate c(cand.pt(), cand.eta(), cand.phi()); + tau.sigGammaList.push_back(c); + sigPtSumGamma += cand.pt(); + } + // Isolation Constituents + // Charged hadrons + double isoPtSumChHad = 0; + for (const reco::CandidatePtr& iCand: v.isolationChargedHadrCands()) { + const reco::Candidate& cand = (*iCand); + vhtm::Candidate c(cand.pt(), cand.eta(), cand.phi()); + tau.isoChHadList.push_back(c); + isoPtSumChHad += cand.pt(); + } + // Neutral hadrons + double isoPtSumNeHad = 0; + for (const reco::CandidatePtr& iCand: v.isolationNeutrHadrCands()) { + const reco::Candidate& cand = (*iCand); + vhtm::Candidate c(cand.pt(), cand.eta(), cand.phi()); + tau.isoNeHadList.push_back(c); + isoPtSumNeHad += cand.pt(); + } + // Photons + double isoPtSumGamma = 0; + for (const reco::CandidatePtr& iCand: v.isolationGammaCands()) { + const reco::Candidate& cand = (*iCand); + vhtm::Candidate c(cand.pt(), cand.eta(), cand.phi()); + tau.isoGammaList.push_back(c); + isoPtSumGamma += cand.pt(); + } + // PtSum + tau.ptSumChargedHadronsIsoCone = isoPtSumChHad; + tau.ptSumNeutralHadronsIsoCone = isoPtSumNeHad; + tau.ptSumPhotonsIsoCone = isoPtSumGamma; + + // tau id. discriminators + tau.decayModeFinding = v.tauID("decayModeFinding"); + tau.decayModeFindingNewDMs = v.tauID("decayModeFindingNewDMs"); + // tau.decayModeFindingOldDMs = v.tauID("decayModeFindingOldDMs"); + + // discriminators against muons + tau.againstMuonLoose = v.tauID("againstMuonLoose"); + tau.againstMuonMedium = v.tauID("againstMuonMedium"); + tau.againstMuonTight = v.tauID("againstMuonTight"); + + tau.againstMuonLoose3 = v.tauID("againstMuonLoose3"); + tau.againstMuonTight3 = v.tauID("againstMuonTight3"); + + // discriminators against electrons + tau.againstElectronLoose = v.tauID("againstElectronLoose"); + tau.againstElectronMedium = v.tauID("againstElectronMedium"); + tau.againstElectronTight = v.tauID("againstElectronTight"); + + tau.againstElectronLooseMVA5 = v.tauID("againstElectronLooseMVA5"); + tau.againstElectronMediumMVA5 = v.tauID("againstElectronMediumMVA5"); + tau.againstElectronTightMVA5 = v.tauID("againstElectronTightMVA5"); + + // DB Corrected Isolation + tau.byLooseCombinedIsolationDeltaBetaCorr3Hits = v.tauID("byLooseCombinedIsolationDeltaBetaCorr3Hits"); + tau.byMediumCombinedIsolationDeltaBetaCorr3Hits = v.tauID("byMediumCombinedIsolationDeltaBetaCorr3Hits"); + tau.byTightCombinedIsolationDeltaBetaCorr3Hits = v.tauID("byTightCombinedIsolationDeltaBetaCorr3Hits"); + tau.byCombinedIsolationDeltaBetaCorrRaw3Hits = v.tauID("byCombinedIsolationDeltaBetaCorrRaw3Hits"); + + // Isolation variables suggested by Christian + tau.chargedIsoPtSum = v.tauID("chargedIsoPtSum"); + tau.neutralIsoPtSum = v.tauID("neutralIsoPtSum"); + tau.puCorrPtSum = v.tauID("puCorrPtSum"); +#if 0 + // who wants to store all the tauIDs? + std::cout << ">>> tauID(label) = value" << std::endl; + for (const pat::Tau::IdPair& pa: v.tauIDs()) + std::cout << pa.first << "=" << pa.second << std::endl; +#endif + // kinematic variables for PFJet associated to PFTau + tau.jetPt = v.pfEssential().p4Jet_.Pt(); + tau.jetEta = v.pfEssential().p4Jet_.Eta(); + tau.jetPhi = v.pfEssential().p4Jet_.Phi(); + + // The following has to be computed from the PackedCandidates of Tau within the signal cone(?) + tau.emFraction = (sigPtSumGamma > 0) ? sigPtSumGamma/v.pt() : 0; + + // Vertex information + const reco::Candidate::Point& vertex = v.vertex(); + tau.vx = vertex.x(); + tau.vy = vertex.y(); + tau.vz = vertex.z(); + + tau.zvertex = v.vz(); // distance from the primary vertex + tau.mass = v.p4().M(); + + tau.dxySig = v.dxy_Sig(); + + // add particle to the list + list_->push_back(tau); + } + fnTau_ = list_->size(); + } + else { + edm::LogError("TauBlock") << "Error! Failed to get pat::Tau collection for label: " + << tauTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(TauBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/TauBlock.h b/AnalysisSpace/TreeMaker/plugins/TauBlock.h new file mode 100644 index 0000000..7bf423e --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TauBlock.h @@ -0,0 +1,53 @@ +#ifndef __AnalysisSpace_TreeMaker_TauBlock_h +#define __AnalysisSpace_TreeMaker_TauBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" +#include "DataFormats/PatCandidates/interface/Tau.h" + +namespace vhtm { + class Tau; +} +class TauBlock : public edm::EDAnalyzer +{ + private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + + public: + explicit TauBlock(const edm::ParameterSet& iConfig); + virtual ~TauBlock(); + + static const reco::PFJetRef& getJetRef(const reco::PFTau& tau); + + enum { + kMaxTau_ = 100 + }; + + private: + std::vector* list_; + int fnTau_; + + const int verbosity_; + const edm::InputTag tauTag_; + const edm::InputTag vertexTag_; + const edm::InputTag bsTag_; + const bool bsCorr_; + + const edm::EDGetTokenT tauToken_; + const edm::EDGetTokenT vertexToken_; + const edm::EDGetTokenT bsToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/TreeMakerModule.cc b/AnalysisSpace/TreeMaker/plugins/TreeMakerModule.cc new file mode 100644 index 0000000..394e68f --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TreeMakerModule.cc @@ -0,0 +1,37 @@ +#include +#include +#include +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" + +#include "TTree.h" + +#include "AnalysisSpace/TreeMaker/plugins/TreeMakerModule.h" +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +TreeMakerModule::TreeMakerModule(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + createTree_(iConfig.getParameter("createTree")) +{ +} +void TreeMakerModule::beginJob() +{ + if (!createTree_) return; + edm::Service fs; + fs->file().cd("/"); + TTree* tree = fs->make("vhtree", "Physics Analysis Level TTree"); + assert(tree); + fs->file().ls(); +} +void TreeMakerModule::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Get TTree pointer + if (createTree_) return; + TTree* tree = vhtm::Utility::getTree("vhtree"); + tree->Fill(); +} +void TreeMakerModule::endJob() { +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(TreeMakerModule); diff --git a/AnalysisSpace/TreeMaker/plugins/TreeMakerModule.h b/AnalysisSpace/TreeMaker/plugins/TreeMakerModule.h new file mode 100644 index 0000000..9dab5ac --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TreeMakerModule.h @@ -0,0 +1,26 @@ +#ifndef __AnalysisSpace_TreeMaker_TreeMakerModule_h +#define __AnalysisSpace_TreeMaker_TreeMakerModule_h + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +class TreeMakerModule : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob(); + +public: + explicit TreeMakerModule(const edm::ParameterSet& iConfig); + virtual ~TreeMakerModule() {} + +private: + const int verbosity_; + const bool createTree_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc b/AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc new file mode 100644 index 0000000..f5ba168 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc @@ -0,0 +1,109 @@ +#include +#include + +#include "TTree.h" +#include "TPRegexp.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h" +#include "DataFormats/Common/interface/TriggerResults.h" + +#include "AnalysisSpace/TreeMaker/plugins/TriggerBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +static const unsigned int NmaxL1AlgoBit = 128; +static const unsigned int NmaxL1TechBit = 64; + +// Constructor +TriggerBlock::TriggerBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + l1Tag_(iConfig.getUntrackedParameter("l1InputTag", edm::InputTag("gtDigis"))), + hltTag_(iConfig.getUntrackedParameter("hltInputTag", edm::InputTag("TriggerResults","","HLT"))), + prescaleTag_(iConfig.getUntrackedParameter("prescaleInputTag", edm::InputTag("patTrigger"))), + hltPathsOfInterest_(iConfig.getParameter >("hltPathsOfInterest")), + l1Token_(consumes(l1Tag_)), + hltToken_(consumes(hltTag_)), + prescaleToken_(consumes(prescaleTag_)) +{ +} +TriggerBlock::~TriggerBlock() { + delete l1physbits_; + delete l1techbits_; + delete hltpaths_; + delete hltresults_; + delete hltprescales_; +} +void TriggerBlock::beginJob() +{ + std::string tree_name = "vhtree"; + TTree* tree = vhtm::Utility::getTree(tree_name); + + l1physbits_ = new std::vector(); + tree->Branch("l1physbits", "vector", &l1physbits_); + + l1techbits_ = new std::vector(); + tree->Branch("l1techbits", "vector", &l1techbits_); + + hltpaths_ = new std::vector(); + tree->Branch("hltpaths", "vector", &hltpaths_); + + hltresults_ = new std::vector(); + tree->Branch("hltresults", "vector", &hltresults_); + + hltprescales_ = new std::vector(); + tree->Branch("hltprescales", "vector", &hltprescales_); +} +void TriggerBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vectors + l1physbits_->clear(); + l1techbits_->clear(); + hltpaths_->clear(); + hltresults_->clear(); + hltprescales_->clear(); + + edm::Handle l1GtReadoutRecord; + bool found = iEvent.getByToken(l1Token_, l1GtReadoutRecord); + if (found && l1GtReadoutRecord.isValid()) { + edm::LogInfo("TriggerBlock") << "Successfully obtained L1GlobalTriggerReadoutRecord for label: " + << l1Tag_; + + for (unsigned int i = 0; i < NmaxL1AlgoBit; ++i) + l1physbits_->push_back(l1GtReadoutRecord->decisionWord()[i] ? 1 : 0); + + for (unsigned int i = 0; i < NmaxL1TechBit; ++i) + l1techbits_->push_back(l1GtReadoutRecord->technicalTriggerWord()[i] ? 1 : 0 ); + } + else + edm::LogError("TriggerBlock") << "Error >> Failed to get L1GlobalTriggerReadoutRecord for label: " + << l1Tag_; + + edm::Handle triggerResults; + found = iEvent.getByToken(hltToken_, triggerResults); + if (found && triggerResults.isValid()) { + edm::LogInfo("TriggerBlock") << "Successfully obtained " << hltTag_; + + edm::Handle triggerPrescales; + iEvent.getByToken(prescaleToken_, triggerPrescales); + + const edm::TriggerNames &names = iEvent.triggerNames(*triggerResults); + for (unsigned int i = 0; i < triggerResults->size(); ++i) { + std::string path = names.triggerName(i); + if (hltPathsOfInterest_.size()) { + int nmatch = 0; + for (auto kt: hltPathsOfInterest_) { + nmatch += TPRegexp(kt).Match(path); + } + if (!nmatch) continue; + } + hltpaths_->push_back(path); + hltprescales_->push_back(triggerPrescales->getPrescaleForIndex(i)); + hltresults_->push_back((triggerResults->accept(i) ? 1 : 0)); + } + } + else { + edm::LogError("TriggerBlock") << "Failed to get TriggerResults for label: " + << hltTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(TriggerBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerBlock.h b/AnalysisSpace/TreeMaker/plugins/TriggerBlock.h new file mode 100644 index 0000000..fc69e42 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TriggerBlock.h @@ -0,0 +1,51 @@ +#ifndef __AnalysisSpace_TreeMaker_TriggerBlock_h +#define __AnalysisSpace_TreeMaker_TriggerBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/Common/interface/Ref.h" + +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Provenance/interface/EventID.h" +#include "FWCore/ParameterSet/interface/ProcessDesc.h" +#include "DataFormats/PatCandidates/interface/PackedTriggerPrescales.h" + +class TriggerBlock: public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit TriggerBlock(const edm::ParameterSet& iConfig); + virtual ~TriggerBlock(); + +private: + + const int verbosity_; + + const edm::InputTag l1Tag_; + const edm::InputTag hltTag_; + const edm::InputTag prescaleTag_; + const std::vector hltPathsOfInterest_; + + std::vector* l1physbits_; + std::vector* l1techbits_; + std::vector* hltpaths_; + std::vector* hltresults_; + std::vector* hltprescales_; + + const edm::EDGetTokenT l1Token_; + const edm::EDGetTokenT hltToken_; + const edm::EDGetTokenT prescaleToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc new file mode 100644 index 0000000..00c48aa --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc @@ -0,0 +1,117 @@ +#include +#include + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "PhysicsTools/PatUtils/interface/TriggerHelper.h" +#include "DataFormats/Common/interface/TriggerResults.h" +#include "FWCore/Common/interface/TriggerNames.h" + +#include "AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" + +#include "TMath.h" +#include "TTree.h" +#include "TPRegexp.h" + +// Constructor +TriggerObjectBlock::TriggerObjectBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + hltPathsOfInterest_(iConfig.getParameter >("hltPathsOfInterest")), + hltPattern_(iConfig.getParameter("hltPattern")), + minTrigObjPt_(iConfig.getUntrackedParameter("minTrigObjPt", 5.0)), + hltTag_(iConfig.getUntrackedParameter("hltInputTag", edm::InputTag("TriggerResults","","HLT"))), + objectTag_(iConfig.getUntrackedParameter("triggerObjectTag", edm::InputTag("selectedPatTrigger"))), + hltToken_(consumes(hltTag_)), + objectToken_(consumes(objectTag_)) +{ + std::cout << "hltPattern = " << std::endl + << hltPattern_ + << std::endl; + re_ = new TPMERegexp(hltPattern_, "xo"); +} +TriggerObjectBlock::~TriggerObjectBlock() { + if (re_) delete re_; +} +void TriggerObjectBlock::beginJob() +{ + std::string tree_name = "vhtree"; + TTree* tree = vhtm::Utility::getTree(tree_name); + list_ = new std::vector(); + tree->Branch("TriggerObject", "std::vector", &list_, 32000, 2); + tree->Branch("nTriggerObject", &fnTriggerObject_, "fnTriggerObject_/I"); +} +void TriggerObjectBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnTriggerObject_ = 0; + + if (verbosity_) { + std::cout << setiosflags(std::ios::fixed); + std::cout << "Indx Eta Phi Pt Energy =Trigger path list=" << std::endl; + } + + edm::Handle triggerBits; + bool found = iEvent.getByToken(hltToken_, triggerBits); + if (found && triggerBits.isValid()) { + edm::Handle triggerObjects; + found = iEvent.getByToken(objectToken_, triggerObjects); + if (found && triggerObjects.isValid()) { + // Find the triggerNames and the matched paths + const edm::TriggerNames& names = iEvent.triggerNames(*triggerBits); + for (const std::string& v: names.triggerNames()) + if (re_->Match(v)) matchedPathList_.push_back(v); + + for (pat::TriggerObjectStandAlone obj: *triggerObjects) { + if (obj.pt() < minTrigObjPt_) continue; + obj.unpackPathNames(names); + + std::map pathInfoMap; + for (const std::string& v: matchedPathList_) { + int val = -1; + if (obj.hasPathName(v, true, true)) val = 3; + else if (obj.hasPathName(v, false, true)) val = 2; + else if (obj.hasPathName(v, true, false)) val = 1; + else if (obj.hasPathName(v, false, false)) val = 0; + if (val > -1) pathInfoMap.insert(std::pair(v, val)); + } + + if (list_->size() == kMaxTriggerObject_) { + edm::LogInfo("TriggerObjectBlock") << "Too many Trigger Muons (HLT), fnTriggerObject = " + << list_->size(); + break; + } + vhtm::TriggerObject _tobj; + _tobj.eta = obj.eta(); + _tobj.phi = obj.phi(); + _tobj.pt = obj.pt(); + _tobj.energy = obj.energy(); + _tobj.pathList = pathInfoMap; + + if (verbosity_) { + std::cout << std::setprecision(2); + std::cout << std::setw(4) << fnTriggerObject_++ + << std::setw(8) << _tobj.eta + << std::setw(8) << _tobj.phi + << std::setw(8) << _tobj.pt + << std::setw(8) << _tobj.energy + << std::endl; + for (auto jt: _tobj.pathList) + std::cout << "\t\t\t\t\t" << jt.first << " " << jt.second << std::endl; + } + list_->push_back(_tobj); + } + fnTriggerObject_ = list_->size(); + } + else { + edm::LogError("TriggerObjectBlock") << "Failed to get TriggerObjects for label: " + << objectTag_; + } + } + else { + edm::LogError("TriggerObjectBlock") << "Failed to get TriggerResults for label: " + << hltTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(TriggerObjectBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h new file mode 100644 index 0000000..de581c2 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h @@ -0,0 +1,60 @@ +#ifndef __AnalysisSpace_TreeMaker_TriggerObjectBlock_h +#define __AnalysisSpace_TreeMaker_TriggerObjectBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/Common/interface/Ref.h" + +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Provenance/interface/EventID.h" +#include "FWCore/ParameterSet/interface/ProcessDesc.h" + +#include "DataFormats/PatCandidates/interface/TriggerObjectStandAlone.h" + +class TPMERegexp; +namespace vhtm { + class TriggerObject; +} + +class TriggerObjectBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit TriggerObjectBlock(const edm::ParameterSet& iConfig); + virtual ~TriggerObjectBlock(); + + enum { + kMaxTriggerObject_ = 100 + }; + +private: + int fnTriggerObject_; + std::vector* list_; + + const int verbosity_; + const std::vector hltPathsOfInterest_; + const std::string hltPattern_; + const double minTrigObjPt_; + + TPMERegexp* re_; + std::vector matchedPathList_; + + const edm::InputTag hltTag_; + const edm::InputTag objectTag_; + + const edm::EDGetTokenT hltToken_; + const edm::EDGetTokenT objectToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/VertexBlock.cc b/AnalysisSpace/TreeMaker/plugins/VertexBlock.cc new file mode 100644 index 0000000..2e212fe --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/VertexBlock.cc @@ -0,0 +1,86 @@ +#include +#include +#include + +#include "TTree.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "DataFormats/VertexReco/interface/Vertex.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/VertexBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +VertexBlock::VertexBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), + vertexToken_(consumes(vertexTag_)) +{} +void VertexBlock::beginJob() { + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("Vertex", "std::vector", &list_, 32000, 2); + tree->Branch("nVertex", &fnVertex_, "fnVertex_/I"); +} +void VertexBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnVertex_ = 0; + + edm::Handle primaryVertices; + bool found = iEvent.getByToken(vertexToken_, primaryVertices); + + if (found && primaryVertices.isValid()) { + edm::LogInfo("VertexBlock") << "Total # of Primary Vertices: " + << primaryVertices->size(); + + if (verbosity_) { + std::cout << std::setprecision(2); + std::cout << " indx x y z rho chi2 ndf" << std::endl; + // std::cout << " indx x y z rho chi2 ndf ntracks sumPt" << std::endl; + } + for (const reco::Vertex& v: *primaryVertices) { + if (list_->size() == kMaxVertex_) { + edm::LogInfo("VertexBlock") << "Too many Vertex, fnVertex = " + << list_->size(); + break; + } + vhtm::Vertex vertex; + vertex.x = v.x(); + vertex.y = v.y(); + vertex.z = v.z(); + vertex.xErr = v.xError(); + vertex.yErr = v.yError(); + vertex.zErr = v.zError(); + vertex.rho = v.position().rho(); + vertex.chi2 = v.chi2(); + vertex.ndf = v.ndof(); + //vertex.ntracks = static_cast(v.tracksSize()); + //vertex.ntracksw05 = v.nTracks(0.5); // number of tracks in the vertex with weight above 0.5 + vertex.isfake = v.isFake(); + vertex.isvalid = v.isValid(); + //vertex.sumPt = v.p4().pt(); + + if (verbosity_) + std::cout << std::setw(7) << list_->size() + << std::setw(7) << vertex.x + << std::setw(7) << vertex.y + << std::setw(7) << vertex.y + << std::setw(7) << vertex.rho + << std::setw(9) << vertex.chi2 + << std::setw(9) << vertex.ndf + //<< std::setw(7) << vertex.ntracks + // << std::setw(7) << vertex.sumPt + << std::endl; + list_->push_back(vertex); + } + fnVertex_ = list_->size(); + } + else { + edm::LogError("VertexBlock") << "Error! Failed to get VertexCollection for label: " + << vertexTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(VertexBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/VertexBlock.h b/AnalysisSpace/TreeMaker/plugins/VertexBlock.h new file mode 100644 index 0000000..8b98d24 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/VertexBlock.h @@ -0,0 +1,40 @@ +#ifndef __AnalysisSpace_TreeMaker_VertexBlock_h +#define __AnalysisSpace_TreeMaker_VertexBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" + +namespace vhtm { + class Vertex; +} +class VertexBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit VertexBlock(const edm::ParameterSet& iConfig); + virtual ~VertexBlock() {} + + enum { + kMaxVertex_ = 150 + }; + +private: + std::vector* list_; + int fnVertex_; + int verbosity_; + edm::InputTag vertexTag_; + edm::EDGetTokenT vertexToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.py b/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.py new file mode 100644 index 0000000..8ecdb68 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.py @@ -0,0 +1,9 @@ +import FWCore.ParameterSet.Config as cms + +electronBlock = cms.EDAnalyzer("ElectronBlock", + verbosity = cms.untracked.int32(1), + beamSpotCorr = cms.untracked.bool(True), + offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot'), + vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + electronSrc = cms.untracked.InputTag('slimmedElectrons') +) diff --git a/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..16664e8b31b33c5723ddfb3a4e28a1969758c80f GIT binary patch literal 596 zcmYjN!A=4(5S;}U1vMIuCf+?kq6aU=D2T>`hGdB*UQB6cwXnM-?O?=<2mip2@yGlC zotE8TciYaq_u6@#`p-`L`ul4vp&UEBpYwDdyeR%7$N;7hOl$C12du-i0jdUS6~{1b zf@;8L1S$?JBO8F50clo93sf^8Oz{n@VPvIg{X^Pb^BKjDZC^Jz++q*U&9O~ zSyS{gBWKiN+|a;SOS=r1G|hB@{SvRv5xyl>(!pAhWIE4L zjjYavUEZT5EzyxTfn{ZXVvlpTl2(RXa7z2kTs?4M?2d#LITG3gsXH)5s-J_q|2Q>S zUvhO0W$viW`|$Fj5ZUsb4fr=M3bI1ZP*Kd8F6j7(8XQfG$wDx;3#3g(Zi@MW#^O0N ztFj!Lb;vBN7k9#`v$7WoIqj0Ukk}hr#9J{#+nX=x#T32jec_HLnd&YRzS3!K)FQ(( P-*xA^-l=Uzo$~twfNYjf literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/EventBlock_cfi.py b/AnalysisSpace/TreeMaker/python/EventBlock_cfi.py new file mode 100644 index 0000000..787f36a --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/EventBlock_cfi.py @@ -0,0 +1,18 @@ +import FWCore.ParameterSet.Config as cms + +eventBlock = cms.EDAnalyzer("EventBlock", + verbosity = cms.untracked.int32(0), + l1InputTag = cms.untracked.InputTag('gtDigis'), + vertexTag = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + vertexMinimumNDOF = cms.untracked.uint32(4), + vertexMaxAbsZ = cms.untracked.double(24.), + vertexMaxd0 = cms.untracked.double(2.), + #trkInputTag = cms.untracked.InputTag('generalTracks'), + #numTracks = cms.untracked.uint32(10), + hpTrackThreshold = cms.untracked.double(0.25), + puSummaryInputTag = cms.untracked.InputTag('addPileupInfo'), + #selectedVtxInputTag = cms.untracked.InputTag('selectedPrimaryVertices'), + selectedVtxInputTag = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + rhoInputTag = cms.untracked.InputTag('kt6PFJets','rho'), + rhoNeutralInputTag = cms.untracked.InputTag('kt6PFNeutralJetsForVtxMultReweighting', 'rho') +) diff --git a/AnalysisSpace/TreeMaker/python/EventBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/EventBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d917e096eda1e89ee7789584454d23114359a1a GIT binary patch literal 946 zcmYk4+m6#P5Qd$ekFeWiVL{>&saGv0AubSf*;2GfEfuX6sW&K%r>R>fsqD$pa@#lH zVR#N+1@QndPSP|^V$Xd4WM-T=|F>ED`0MA?Vaa$zYmXlNhbB(9#Ux`Zi>-2OmS>P> zs{-RW#$&t4Rwc#@Y;Q4Mj8r0J#!C??XGkR?)dQ(8UW-WmK&p&4BGSx|I}y2?AtwHH@?gkVJ z2Q;2i1ZAiAq40$ldZYg5fhd?N&7)**FXwvZ5}@(Ahjm(#x9lx{nh30iCnPL4Q)N5r z=~97S29hW0?{`tLO*jcX(?Z(5sbh0K781hEwZ91PjEDva4g$ZyZ5nCHs%4P+=F_b4 z)p+m;P-8w;u@$c)2vONG4SsS6P6YGLAW)Ql7)tyC-$A%b6u#RwWzd|*!Pl!mL1%0$ z+XDnO0qk4_{zACeAUVsiL?F>jBaWxzAKAb3ZMpkFpV)L8`qY!N298DYgpV(tV}-1= zOOqyyxiNVV&Lu>dAUzUo64-IlFUi%)=|+{b(36erKzFJDhV~j%ceBG~;CGK_>YK9= g9ipc48!zCYgtwMSazRro*RWd0D^GT=Wu0690TlA+;Q#;t literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/GenEventBlock_cfi.py b/AnalysisSpace/TreeMaker/python/GenEventBlock_cfi.py new file mode 100644 index 0000000..7d099dd --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/GenEventBlock_cfi.py @@ -0,0 +1,8 @@ +import FWCore.ParameterSet.Config as cms + +genEventBlock = cms.EDAnalyzer("GenEventBlock", + verbosity = cms.untracked.int32(0), + GenEventInfoInputTag = cms.untracked.InputTag('generator'), + PDFWeightsInputTag = cms.untracked.InputTag('pdfWeights','cteq66'), + StorePDFWeights = cms.untracked.bool(False) +) diff --git a/AnalysisSpace/TreeMaker/python/GenEventBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/GenEventBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..724b5a0b4d6bb46f35f347e11d96b940127e96ee GIT binary patch literal 566 zcmY*V%}xR_5T0fE7h*#6;uCO!L=(Iiqw*IH8WKoIxR|mXU}0(3b|AqkZ{WlDVm^S* zRs?Lj?acSh%r`s!SGm~z{1^tXUuXP2@MmMbBp(kVfQ1K(6pVd99~NnlDUiQ*1{PV6 zY1nxnGmd2>2QurB+zFBgS%4iU7XQFJAR`{1^thM^4XTNH_|5Bu%4~K~wKu5fDbm4` z3XE*fOtcMY8?pm*aT3&1Q{7YXnucQLVrQt(2-1cs9M*4jMi|cKWDh|_hGRM1!<1z= zAbe{y=$y>~XW}u-^+s1rbVf~PYJFkE3JJ{ssn*nL8qTQ1^eOIY?m0gxzp|95wp))% zMB8^XuG6(5BZ4JL$}kx!y1Ax2TZc~5>`b(d9N!US*!{dCa90SM8-m+^=PHPq$o{X{p literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/GenJetBlock_cfi.py b/AnalysisSpace/TreeMaker/python/GenJetBlock_cfi.py new file mode 100644 index 0000000..cb65b12 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/GenJetBlock_cfi.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +genJetBlock = cms.EDAnalyzer('GenJetBlock', + verbosity = cms.untracked.int32(0), + genJetSrc = cms.untracked.InputTag('slimmedGenJets') +) diff --git a/AnalysisSpace/TreeMaker/python/GenJetBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/GenJetBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..11cf1dc81262983773a4273494cb589d5ececa91 GIT binary patch literal 423 zcmYjN%}N6?5T5Mz&ssh7=o9qR1;v|)TD4SAge?fYNKB?R+udwQrowvd8~8B3m=BLn<4SfQFr|PHC3>)HpeTze!@=k5s(990n>QhAfo{M? zfNs_-BW=*FfNVrG>jZ^#5M<3S+Y=pfI!60|bd#5ANe5hipnEI5p~`RpHMFRoq)yQ> zLq0b}fqL8L2cd^f*xkR3N{7Q|>12U~E=3xSN;@|T>M^~KQ;UHe7jvo#PhF08x7SwY z)hD`o?%I-*YKfYfOd3mPr_|wWVpnUL%0<2ZcDZ{00dw&0{5hB2siYS5#-}T(Fqt~U mN4Z3otSWjhZL;?RuWD|F42LNfMXA?0UW%X+7Vbwq(HDQPIA|CE literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/GenMETBlock_cfi.py b/AnalysisSpace/TreeMaker/python/GenMETBlock_cfi.py new file mode 100644 index 0000000..beca60f --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/GenMETBlock_cfi.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +genMETBlock = cms.EDAnalyzer('GenMETBlock', + verbosity = cms.untracked.int32(0), + genMETSrc = cms.untracked.InputTag('genMetTrue') +) diff --git a/AnalysisSpace/TreeMaker/python/GenMETBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/GenMETBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..065d47194e79f5ab0517ba3044ac93fe2faf6420 GIT binary patch literal 419 zcmYjM%}xR_5T5SxC*p;pPr!*yG~SF+5eWy3$!=o8#ng7dF3T=yXHD?R8~8B3m=B=S zLL!rP`hDL_zL~~9XWhy7SEk?)ZGLb0x+y2kM?e9P3&0IKgr@&hCp!t>}dL2imvF8QK~q5Ts>jNv)zT zOP(QRw#I?)r*lq^FQdxh@L5{9Mnan+4M$bEFiYxj`B-y-3MHQ|KzTiI;)ak>WoV_Qel!=#F<>7 jO*UJ4ugc`;_pfSUhAjIj*Xv5x1>Okn;ur2mJ<%6`<-28t literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/GenParticleBlock_cfi.py b/AnalysisSpace/TreeMaker/python/GenParticleBlock_cfi.py new file mode 100644 index 0000000..3e30295 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/GenParticleBlock_cfi.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +genParticleBlock = cms.EDAnalyzer("GenParticleBlock", + verbosity = cms.untracked.int32(0), + genParticleSrc = cms.untracked.InputTag('prunedGenParticles') +) diff --git a/AnalysisSpace/TreeMaker/python/GenParticleBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/GenParticleBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..126de4508135a01b60ed6d71e18d2ace18d84424 GIT binary patch literal 447 zcmYjM+e!m55S{GyW~m~5^b7jb1$`3{@1+llumzzn5|e4ocAH(2S)so65BwN^%n#7X zTIdeRT+W%C%)~#3{mJ*&Ou^2&9IyELDLc(aKn{=z$Re1>fH7n(&=KhWybW0gbPKiu zbh~C5>4NSAWGkY1FDRs=AZvcvp6Hm<3EF4r$fz7|@Tx!;WkoZ&thZ@QS#LAq2G~1)&ZT!Msg=F)X(<&Z rGl%#nSLl**L+^!68avf8uWDh&%!U6h)`hNeyc9tyj6RG8VkrIqoR)GZ literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/JetBlock_cfi.py b/AnalysisSpace/TreeMaker/python/JetBlock_cfi.py new file mode 100644 index 0000000..3646446 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/JetBlock_cfi.py @@ -0,0 +1,9 @@ +import FWCore.ParameterSet.Config as cms + +jetBlock = cms.EDAnalyzer("JetBlock", + verbosity = cms.untracked.int32(0), + jetSrc = cms.untracked.InputTag('slimmedJets'), + jecUncertainty = cms.string('CondFormats/JetMETObjects/data/Spring10_Uncertainty_AK5PF.txt'), + applyResidualJEC = cms.bool(False), + residualJEC = cms.string('CondFormats/JetMETObjects/data/Spring10_L2L3Residual_AK5PF.txt') +) diff --git a/AnalysisSpace/TreeMaker/python/JetBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/JetBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd5c3f1bc9b3ea5a6d35c896044000b905273bb9 GIT binary patch literal 678 zcmb7B+fExX5S`79kU*(;>=*EqZG-yOqC%RWQf}%7A@LG9_Kau%+ zbY!et(k6pDbaU%9)tUiNhfR)@IZ1tXz0pO1iYq+5i6MDaN^~T2NwxpX)X0`JHp*{izQ;rEZ1lL6fmz2y#~s!aU@y;dt>PR64+*{!iZ z_>VEC!_)njUh6qg0(!@NCf6hDaBwM{D3H))NCUpYtzJ-&=`|n4c#btWCJRqJKF41V zOJV8h@bH;QHb9Cyfws8pt##;UGdZIRO{aHAPGqIx%g9GZftWZ=c z20%>?2~wa1nNvlqk_086D5%R=WLj796~jCtBZXy-3nQT*l(uYgh^oB)DQ`LVktU`8 zJRTTZy5=x{nPwV?%SfAK)B)0Pnx$*Cp&rZUylt$~T-HQ#YH0Q_PNTT|Ky7XJDd|Y; zxQPZQsg!O;_R5Pi-%}WEEMPBt{{g4Ke<(%_3oSfbu~0>jM*_W2Bl^(}wU?Llo~7R3 d_+G_Y4Vg0|y-hN?kMYhiCCs2MYdz=EKELShem4LB literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.py b/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.py new file mode 100644 index 0000000..0f3c8ee --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.py @@ -0,0 +1,10 @@ +import FWCore.ParameterSet.Config as cms + +muonBlock = cms.EDAnalyzer("MuonBlock", + verbosity = cms.untracked.int32(0), + muonSrc = cms.untracked.InputTag('slimmedMuons'), + vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot'), + beamSpotCorr = cms.untracked.bool(True), + muonID = cms.untracked.string('GlobalMuonPromptTight') +) diff --git a/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7a0927cabab45c8cbb402b21f94e1e480f0dbbf0 GIT binary patch literal 644 zcmYjN&2HN;45ss+G~Iv#y$t9*rvzB9!?3m8iXJ)yu(1NY6pF;8N+ipW=wjKmPq01A zUThDrQi{_>wyBRF$&WPKe~(Ake|{Gdn)8lWO%0o$#VLuafd1pOl+en@gn)G~)Zq)#p-}?N6REuA?r=3%Nl> zUG{WI=kIC2=%%b{D#VI9>@1u!2^7A@Bpk@=a+MU~zS2S`oC*I;IA=F_IZOS54tXUc t&I*rsD>mq7)s`MzIg3A=>L27%PnnGEKUk+~gCDb~@rKPwYn+|DJ}>fBpVt5Y literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/TauBlock_cfi.py b/AnalysisSpace/TreeMaker/python/TauBlock_cfi.py new file mode 100644 index 0000000..607b5da --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/TauBlock_cfi.py @@ -0,0 +1,9 @@ +import FWCore.ParameterSet.Config as cms + +tauBlock = cms.EDAnalyzer("TauBlock", + verbosity = cms.untracked.int32(0), + patTauSrc = cms.untracked.InputTag('slimmedTaus'), + vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + beamSpotCorr = cms.untracked.bool(True), + offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot') +) diff --git a/AnalysisSpace/TreeMaker/python/TauBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/TauBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..634e0b8f9832275337e4cc9bd0a1b288cb1daaf0 GIT binary patch literal 574 zcmYk2%}&EG49DGdpJfPXMe>@(k&E{AXmx+-J z>ag>Uc4C~SrDg{_$^~&qY$cV6F41XE5vyi8O>~CwI%s5dD(vzJEoq64 zx*Rb^dul{tl;IoC}G=u|<3k3$(+0NpB__Zuj&?e*XF~53#+<{C>uk{bqN>j|T~?J*-O*Ws8&` zD^OL4Dm=p|L)M_`5Oo(GV|@Usg6bI3fUV8eVe7H^Y)uTmdl0wH z&Ss-M-evTcuQwx)KXr>8ol>k{$Rs>=Sevm^N;Q4Ufei-Nl&ASdDk;=y5?>*zOT;D< z)#g8vUTku*E|XRizgwg_3MJ)6%#w8)tyYxg(Ebj6`+3c)aAS82Y~0I_he=8S=Ueb< zD4mfG4wHBpt+Yv)$90W??U-qYP-Xf)zn{kod6q@l>|_yAFi(l5i(^WI$wj?Bh0EwY zGoc?8@IUNoX$7|McMAlsx8<|!l1cxtfIZ2dft8p|=%NXxlesOIWmgRQUcm&@^Ru(` z>UGKI+jF&SQ(FC~Ao;5+XKqz>qZ$>c=DB{b3e%oCxL%R#6{|D7sf~C>UpEwoqz4A! zv*w1-{9l~oW;NKk>@kN~8jdeD$@rp4#wTa`OA=dPo5^(;&$0*fpli{-Nyd9 zC$BxoE>sVqm)8x*hfsZpJ{)qfIssKcH4Mn(XmYeT+8iB@9!DR89}dL8>}EP_^3I~a ze7zq!{8u+P(KW^TwM@dx95bA2N;TaSz?LCO3U!*q1=wR)t#_b0LpoR&NCsI^v4ug@ z4sv8vX|!BYT2OYk=!dT>?w-GUWZ=h~-h4SvQu03rX~4@-IwkF&C-EX$YO`Pw*Hs2K z?~Ku*%JegSp2dN@&7y326@=u^Qld$4NvS`+pUOqJh(0kB`uQII=k3I-z>fFD9>KUc zO)Dvx9#8j3CU=vzbh8WnWDk9|alx|7huH5nepq(p5PLG7SuZTxj8+f#eM!MttEd@; ze^^m)-RkV&GHFWR*A$1OduAnejjh#uj_+{uHQ1)?l*=p)M>}?p?(H63-Rf^iY=O;6 l`B}M`2Rh)^3!fRL@k^D=*OFctf3p)#-O{o1-(9MD{{Sr5Aj1Fv literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/TreeCreator_cfi.py b/AnalysisSpace/TreeMaker/python/TreeCreator_cfi.py new file mode 100644 index 0000000..98c8ad9 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/TreeCreator_cfi.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +treeCreator = cms.EDAnalyzer("TreeMakerModule", + verbosity = cms.untracked.int32(1), + createTree = cms.bool(True) +) diff --git a/AnalysisSpace/TreeMaker/python/TreeCreator_cfi.pyc b/AnalysisSpace/TreeMaker/python/TreeCreator_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37b8f2671b4180f3c9c909754d37c56a647c4137 GIT binary patch literal 411 zcmYjN%}N6?5T5Mz--^(qPq3#J6mKF*wLMjYEeO3xnoKp@?WQDCpi#z#;`qp=f|kK>y$-6fMvVI0(?q z=xqab0zHUi(GBT&*5Xp;i`PA!Fq}KYnOvirS-mTfx~#pTTUu{uZv->yu~7~sVF=Cw zrBgPO$FX%de2`9VkkI8w!?CSa=9&8J{;yN$TKiIlYU5+syW5*emisq!vGJ}VC)FA? zH95#sbbdw+MoVkU2eL}lTQM8X6_B$!g@nHBiN!2gK{VdLvTNs zbjC2AjjY4LlXP;8gswmujBLF$FVtoCf1X0uqc3Gut$i$ee|KBUYWI#VHs03cq*|e- zoP$hF7w43*wy?H})L2#?VQfc94M~fXq^PV^DKE%bo5f&ukv$uUK9)b| z$Mnbg0qwCt1bcTp=gfHKc;de&tuKFmCn@dL8P1RR-7gr4FCs%Uk7!<@hnQ4M^D4;- z$*o_bd7WgHHWA5Mh=OU5tOurXz#Nfml5Ei?CV3oqFl~}2Bu`1cAo-Hy8OaW98n|11 zKypOm?m1-We^~e2hMQQOWy*dwMY`Z7h$m$q3#WOl0f<{L=FKo)m7Iu-8-N)Pbfz62 z!=D-6$4-HF<-RLd8g>kZIEMLpn{Wpw@<)Pa?%Q;jv$D!@P=WAdP?V2G-IZM5=1<^y zK|VHg1(4V45t^(*<`D>lMmLElgS5mhfRo_+%xj~%{ssIR=H|y$VO4J=tXL{EA1m%% z75P+Wq4FUgH0)wte!6sF64!%IxiIUW$_8m=&Q_!gCAo$qo%6f595fw{>&daz`L+kV z{j|HdLeIv%2Xr>=hYn7=@k*qspID{t#6sErYR$7E2k~5Dl1_CGyzlv8S;*3;%gC3x Rfaz4)Q3v}~)QsZ&{tvS>qE!F@ literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py b/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py new file mode 100644 index 0000000..7f0cc7f --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py @@ -0,0 +1,33 @@ +import FWCore.ParameterSet.Config as cms + +triggerObjectBlock = cms.EDAnalyzer("TriggerObjectBlock", + verbosity = cms.untracked.int32(0), + hltInputTag = cms.untracked.InputTag('TriggerResults','','HLT'), + triggerEventTag = cms.untracked.InputTag('patTriggerEvent'), + hltPathsOfInterest = cms.vstring ("HLT_DoubleMu", + "HLT_Mu13_Mu8_v", + "HLT_Mu17_Mu8_v", + "HLT_Mu1", + "HLT_Mu2", + "HLT_Mu3", + "HLT_Mu4", + "HLT_IsoMu1", + "HLT_IsoMu2", + "HLT_IsoMu3", + "HLT_IsoMu4", + "HLT_Mu17_Ele8_Calo", + "HLT_Mu8_Ele17_", + "HLT_Ele1", + "HLT_Ele2", + "HLT_Ele3", + "HLT_Ele4", + "IsoPFTau"), + hltPattern + = cms.string(r""" +HLT_(Mu\\d{1,2}_Ele\\d{1,2}_(?:Calo)? | +Ele[1-4][0-9] | +[^(QuadJet\\d+_)]IsoPFTau) +"""), + minTrigObjPt = cms.untracked.double(8.0), + May10ReRecoData = cms.untracked.bool(False) +) diff --git a/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..080f4781d12f021c2547f0cf72a0ab1e54ac5436 GIT binary patch literal 1182 zcmah|>2A|N5FRJ#ku+@~T%{B!@Fx}Y$RV|$iWYi65uu^Agwz9T^I}xar*ao?#<61rVa6!;rBW}>K7a2+W;4!Wk4$h z2WgOLXk`FXfCGOBTEl=D=o^4TdX||HKqlFaLO%_dP4GD#Ii{IWz&zkM-~`|#;5ESO zfCa!CfHwhe0p13@12_eE7jPQz9^ee%edu${1Fet+e5eIy&r{?8A8F?CIm5Z~5z{wD z4mg(q`^6{xY0e)WAE>~t892?R40anWY13=hx6dfcbXNuqUpdrs7yym2Idy5r>x5*A zCQUGoSMEs_x}-?QrP;oHZ_*^cX`sB-m7ZP`aUDVNGEM6WShp_dRPCPZcq9XXDn;`klqM@z22@>N*53ah&E zxT0li%atqEhH(8vRVxu&TDE93&Jw{SC?`QB391@!RrPICggWzJlX!bPWwKr_N?ojl zM@RUz^sM|n%5~uv*Iq=m%&pCS%Q1ggny(%oF3mqbW_Cvh0G4bzjW7#Lp0?$Urz1sFMbmdDU605Q)r1D0=nBpgEr2lheQ^T1oNB#wC6&?@( literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.py b/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.py new file mode 100644 index 0000000..e046b01 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +vertexBlock = cms.EDAnalyzer("VertexBlock", + verbosity = cms.untracked.int32(1), + vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices') +) diff --git a/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f088c0124e47629d3be06cbf2a49f960f3daa8cd GIT binary patch literal 438 zcmYjN$xZ_?40UF@QOc!9B9uP^GCr>IH?wQ!<@RiHjJn{R2LRAL9eS zDXplLczG{+u^oONbnm`CrwTUK=6J!^joE2F0y2P9KpMa-1Pmc=kp?xWxq1p(pwh%vwt)e4_ z$|T85fpKQ?9QDMST-w^J7=>=&CFqdd?bE2VIGji;b0oAe(r{E3iJ4Q6>0O*!3~acN zQTotLswGY3d_4}gza3}59Q-?X%B8a^ xT8ld4;z}xvrWWyDF3?6*O|NAU?JVS3C1%L5|K%(%^)kbAzZK^j?gu^57r)-LZ)gAj literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/__init__.py b/AnalysisSpace/TreeMaker/python/__init__.py new file mode 100644 index 0000000..3689cc8 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/__init__.py @@ -0,0 +1,3 @@ +#Automatically created by SCRAM +import os +__path__.append(os.path.dirname(os.path.abspath(__file__).rsplit('/AnalysisSpace/TreeMaker/',1)[0])+'/cfipython/slc5_amd64_gcc481/AnalysisSpace/TreeMaker') diff --git a/AnalysisSpace/TreeMaker/python/__init__.pyc b/AnalysisSpace/TreeMaker/python/__init__.pyc new file mode 100644 index 0000000000000000000000000000000000000000..175c90a395cb362077e5711bb0d5787e20ef0210 GIT binary patch literal 394 zcmZ`zy-ou$4EFuC6@nS{4Q}cQ=|Bt!!GsuKX(yH_ByO7{my6;sbnYAQFuWKK08Tl? zR4e}c*|9%;#n;)%!{^6J!59_SJ5G9J(EKv6051TTL6-vpbOm(fAE^K*u;;HS=p1wb zd&UyxJkk}MbIDj?Sx;Ead~-b0oN06Kq}`FBrI!kuRX}`_Zx|YrrA1DlHtngk@w>Pk zTtik}3fb$cR&11NuP=^i)H6PeIm19PaUr~nTOndHA-zYZW63m4 +#include "TTree.h" + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +TTree* vhtm::Utility::getTree(const std::string& tree_name) { + edm::Service fs; + TTree *tree = dynamic_cast(fs->file().FindObjectAny(tree_name.c_str())); + assert(tree); + return tree; +} diff --git a/AnalysisSpace/TreeMaker/src/classes.h b/AnalysisSpace/TreeMaker/src/classes.h new file mode 100644 index 0000000..029cd27 --- /dev/null +++ b/AnalysisSpace/TreeMaker/src/classes.h @@ -0,0 +1,39 @@ +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" + +#include + +namespace { + struct dictionary { + vhtm::Event rv1; + vhtm::GenEvent rv2; + vhtm::Electron rv3; + vhtm::GenParticle rv4; + vhtm::GenJet rv5; + vhtm::GenMET rv6; + vhtm::MET rv7; + vhtm::Tau rv8; + vhtm::Muon rv9; + vhtm::Jet rva; + vhtm::Vertex rvb; + vhtm::TriggerObject rvd; + vhtm::Candidate rve; + vhtm::Photon rvf; + + std::vector vrv1; + std::vector vrv2; + std::vector vrv3; + std::vector vrv4; + std::vector vrv5; + std::vector vrv6; + std::vector vrv7; + std::vector vrv8; + std::vector vrva; + std::vector vrvb; + std::vector vrvc; + std::vector vrvd; + std::vector vrve; + std::vector vrvf; + std::vector vrvg; + std::map > vrvm; + }; +} diff --git a/AnalysisSpace/TreeMaker/src/classes.h.save b/AnalysisSpace/TreeMaker/src/classes.h.save new file mode 100644 index 0000000..4b3124e --- /dev/null +++ b/AnalysisSpace/TreeMaker/src/classes.h.save @@ -0,0 +1,32 @@ +#include "ExoticHiggs/TreeMaker/interface/PhysicsObjects.h" + +#include + +namespace { + struct dictionary { + vhtm::Event rv1; + vhtm::GenEvent rv2; + vhtm::Electron rv3; + vhtm::GenParticle rv4; + vhtm::GenJet rv5; + vhtm::GenMET rv6; + vhtm::MET rv7; + vhtm::Tau rv8; + vhtm::Muon rv9; + vhtm::Jet rva; + vhtm::Vertex rvb; + vhtm::Track rvc; + vhtm::TriggerObject rvd; + + std::vector vrv1; + std::vector vrv2; + std::vector vrv3; + std::vector vrv4; + std::vector vrv5; + std::vector vrv6; + std::vector vrv7; + std::vector vrv8; + std::vector vrv9; + std::vector vrva; + }; +} diff --git a/AnalysisSpace/TreeMaker/src/classes_def.xml b/AnalysisSpace/TreeMaker/src/classes_def.xml new file mode 100644 index 0000000..67bdc5f --- /dev/null +++ b/AnalysisSpace/TreeMaker/src/classes_def.xml @@ -0,0 +1,59 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py b/AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py new file mode 100644 index 0000000..b8f2411 --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py @@ -0,0 +1,95 @@ +## import skeleton process +from PhysicsTools.PatAlgos.patTemplate_cfg import * + +process.options.allowUnscheduled = cms.untracked.bool(True) + +## to run in un-scheduled mode uncomment the following lines +#process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") +#process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff") + +#from PhysicsTools.PatAlgos.tools.metTools import addMETCollection +#addMETCollection(process, labelName='patMETsTypeIcorrected', metSource='pfType1CorrectedMet') +#addMETCollection(process, labelName='patMETTC', metSource='tcMet') + +runOnMC=True +# An empty postfix means that only PF2PAT is run, +# otherwise both standard PAT and PF2PAT are run. In the latter case PF2PAT +# collections have standard names + postfix (e.g. patElectronPFlow) +postfix = "" +jetAlgo = "AK5" +#Define Objects to be excluded from Top Projection. Default is Tau, so objects are not cleaned for taus +excludeFromTopProjection=['Tau'] + +# Configure PAT to use PF2PAT instead of AOD sources +# this function will modify the PAT sequences. +from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT +usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=postfix, excludeFromTopProjection=excludeFromTopProjection) + +#from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection +#from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection + +## uncomment the following lines to add ak5PFJetsCHS to your PAT output +#postfixAK5PFCHS = 'Copy' +#addJetCollection( +# process, +# postfix = postfixAK5PFCHS, +# labelName = 'AK5PFCHS', +# jetSource = cms.InputTag('ak5PFJetsCHS'), +# jetCorrections = ('AK5PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-2') +#) +#process.out.outputCommands.append( 'drop *_selectedPatJetsAK5PFCHS%s_caloTowers_*'%( postfixAK5PFCHS ) ) + +# uncomment the following lines to add ak5PFJets to your PAT output +#addJetCollection( +# process, +# labelName = 'AK5PF', +# jetSource = cms.InputTag('ak5PFJets'), +# jetCorrections = ('AK5PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'), +# btagDiscriminators = [ +# 'jetBProbabilityBJetTags' +# , 'jetProbabilityBJetTags' +# , 'trackCountingHighPurBJetTags' +# , 'trackCountingHighEffBJetTags' +# , 'simpleSecondaryVertexHighEffBJetTags' +# , 'simpleSecondaryVertexHighPurBJetTags' +# , 'combinedSecondaryVertexBJetTags' +# ], +#) +#process.out.outputCommands.append( 'drop *_selectedPatJetsAK5PF_caloTowers_*' ) +process.patJets.addJetID=True +process.patJets.jetIDMap="ak5JetID" +#process.patJets.useLegacyJetMCFlavour=True + +#from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValProdTTbarAODSIM +#process.source.fileNames = filesRelValProdTTbarAODSIM +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( + '/store/mc/Fall13dr/WH_ZH_HToTauTau_M-125_13TeV_pythia6/AODSIM/tsg_PU40bx25_POSTLS162_V2-v1/00000/087890E7-6A80-E311-8AA4-001E67398110.root' + ), + skipEvents = cms.untracked.uint32(0) +) +process.maxEvents.input = 10 + +# Output +from PhysicsTools.PatAlgos.patEventContent_cff import patExtraAodEventContent +process.out.fileName = cms.untracked.string('patTuple_mc.root') +#process.out.outputCommands.extend(patExtraAodEventContent) +#process.out.outputCommands += ['drop recoGenJets_*_*_*' ] +#process.out.outputCommands += [ +# 'keep recoVertexs_goodOfflinePrimaryVertices_*_*', +# 'keep PileupSummaryInfos_*_*_*', +# 'keep *_ak5GenJets_*_*', +# 'keep *_kt6GenJets_*_*', +# 'keep *_genMetTrue_*_*', +# #'keep *_kt6PFJets_*_*', +# 'keep recoPFJets_ak5PFJets_*_*', +# 'keep *_*GsfElectrons*_*_*', +# 'keep *_electronGsfTracks_*_*' +#] +print process.out.outputCommands.dumpPython() +process.load('PhysicsTools.PatAlgos.patSequences_cff') +process.p = cms.Path( +# process.kt6PFJets* + process.patDefaultSequence +) +process.options.wantSummary = False diff --git a/AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py.save b/AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py.save new file mode 100644 index 0000000..e69de29 diff --git a/AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py.save.1 b/AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py.save.1 new file mode 100644 index 0000000..ecf3f4e --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/IntegrationTest_cfg.py.save.1 @@ -0,0 +1,94 @@ +## import skeleton process +from PhysicsTools.PatAlgos.patTemplate_cfg import * + +process.options.allowUnscheduled = cms.untracked.bool(True) + +## to run in un-scheduled mode uncomment the following lines +#process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") +#process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff") + +#from PhysicsTools.PatAlgos.tools.metTools import addMETCollection +#addMETCollection(process, labelName='patMETsTypeIcorrected', metSource='pfType1CorrectedMet') +#addMETCollection(process, labelName='patMETTC', metSource='tcMet') + +runOnMC=True +# An empty postfix means that only PF2PAT is run, +# otherwise both standard PAT and PF2PAT are run. In the latter case PF2PAT +# collections have standard names + postfix (e.g. patElectronPFlow) +postfix = "" +jetAlgo = "AK5" +#Define Objects to be excluded from Top Projection. Default is Tau, so objects are not cleaned for taus +excludeFromTopProjection=['Tau'] + +# Configure PAT to use PF2PAT instead of AOD sources +# this function will modify the PAT sequences. +from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT +usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=postfix, excludeFromTopProjection=excludeFromTopProjection) + +#from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection +#from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection + +## uncomment the following lines to add ak5PFJetsCHS to your PAT output +#postfixAK5PFCHS = 'Copy' +#addJetCollection( +# process, +# postfix = postfixAK5PFCHS, +# labelName = 'AK5PFCHS', +# jetSource = cms.InputTag('ak5PFJetsCHS'), +# jetCorrections = ('AK5PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-2') +#) +#process.out.outputCommands.append( 'drop *_selectedPatJetsAK5PFCHS%s_caloTowers_*'%( postfixAK5PFCHS ) ) + +# uncomment the following lines to add ak5PFJets to your PAT output +#addJetCollection( +# process, +# labelName = 'AK5PF', +# jetSource = cms.InputTag('ak5PFJets'), +# jetCorrections = ('AK5PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-1'), +# btagDiscriminators = [ +# 'jetBProbabilityBJetTags' +# , 'jetProbabilityBJetTags' +# , 'trackCountingHighPurBJetTags' +# , 'trackCountingHighEffBJetTags' +# , 'simpleSecondaryVertexHighEffBJetTags' +# , 'simpleSecondaryVertexHighPurBJetTags' +# , 'combinedSecondaryVertexBJetTags' +# ], +#) +#process.out.outputCommands.append( 'drop *_selectedPatJetsAK5PF_caloTowers_*' ) +#process.patJets.addJetID=True +#process.patJets.jetIDMap="ak5JetID" +#process.patJets.useLegacyJetMCFlavour=True + +#from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValProdTTbarAODSIM +#process.source.fileNames = filesRelValProdTTbarAODSIM +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( + '/store/mc/Fall13dr/WH_ZH_HToTauTau_M-125_13TeV_pythia6/AODSIM/tsg_PU40bx25_POSTLS162_V2-v1/00000/087890E7-6A80-E311-8AA4-001E67398110.root' + ), + skipEvents = cms.untracked.uint32(0) +) +process.maxEvents.input = 10 + +# Output +from PhysicsTools.PatAlgos.patEventContent_cff import patExtraAodEventContent +process.out.fileName = cms.untracked.string('patTuple_mc.root') +process.out.outputCommands.extend(patExtraAodEventContent) +process.out.outputCommands += ['drop recoGenJets_*_*_*' ] +process.out.outputCommands += ['keep recoVertexs_goodOfflinePrimaryVertices_*_*', + 'keep PileupSummaryInfos_*_*_*', + 'keep *_ak5GenJets_*_*', + 'keep *_kt6GenJets_*_*', + 'keep *_genMetTrue_*_*', + #'keep *_kt6PFJets_*_*', + 'keep recoPFJets_ak5PFJets_*_*', + 'keep *_*GsfElectrons*_*_*', + 'keep *_electronGsfTracks_*_*' +] +print process.out.outputCommands.dumpPython() +process.load('PhysicsTools.PatAlgos.patSequences_cff') +process.p = cms.Path( +# process.kt6PFJets* + process.patDefaultSequence +) +process.options.wantSummary = False diff --git a/AnalysisSpace/TreeMaker/test/WH_ZH_HToTauTau_M_125_TuneZ2star_13TeV_pythia6_cff.py b/AnalysisSpace/TreeMaker/test/WH_ZH_HToTauTau_M_125_TuneZ2star_13TeV_pythia6_cff.py new file mode 100644 index 0000000..13cc4e4 --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/WH_ZH_HToTauTau_M_125_TuneZ2star_13TeV_pythia6_cff.py @@ -0,0 +1,60 @@ +import FWCore.ParameterSet.Config as cms + +from Configuration.Generator.PythiaUEZ2starSettings_cfi import * +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * + +generator = cms.EDFilter("Pythia6GeneratorFilter", + pythiaPylistVerbosity = cms.untracked.int32(1), + # put here the efficiency of your filter (1. if no filter) + filterEfficiency = cms.untracked.double(1.0), + pythiaHepMCVerbosity = cms.untracked.bool(False), + # put here the cross section of your process (in pb) + crossSection = cms.untracked.double(1.0), + maxEventsToPrint = cms.untracked.int32(1), + comEnergy = cms.double(13000.0), + ExternalDecays = cms.PSet( + Tauola = cms.untracked.PSet( + TauolaPolar, + TauolaDefaultInputCards + ), + parameterSets = cms.vstring('Tauola') + ), + PythiaParameters = cms.PSet( + pythiaUESettingsBlock, + processParameters = cms.vstring('PMAS(25,1)=125.0 !mass of Higgs', + 'MSEL=0 ! user selection for process', + 'MSUB(102)=0 !ggH', + 'MSUB(123)=0 !ZZ fusion to H', + 'MSUB(124)=0 !WW fusion to H', + 'MSUB(24)=1 !ZH production', + 'MSUB(26)=1 !WH production', + 'MSUB(121)=0 !gg to ttH', + 'MSUB(122)=0 !qq to ttH', + 'MDME(210,1)=0 !Higgs decay into dd', + 'MDME(211,1)=0 !Higgs decay into uu', + 'MDME(212,1)=0 !Higgs decay into ss', + 'MDME(213,1)=0 !Higgs decay into cc', + 'MDME(214,1)=0 !Higgs decay into bb', + 'MDME(215,1)=0 !Higgs decay into tt', + 'MDME(216,1)=0 !Higgs decay into', + 'MDME(217,1)=0 !Higgs decay into Higgs decay', + 'MDME(218,1)=0 !Higgs decay into e e', + 'MDME(219,1)=0 !Higgs decay into mu mu', + 'MDME(220,1)=1 !Higgs decay into tau tau', + 'MDME(221,1)=0 !Higgs decay into Higgs decay', + 'MDME(222,1)=0 !Higgs decay into g g', + 'MDME(223,1)=0 !Higgs decay into gam gam', + 'MDME(224,1)=0 !Higgs decay into gam Z', + 'MDME(225,1)=0 !Higgs decay into Z Z', + 'MDME(226,1)=0 !Higgs decay into W W'), + # This is a vector of ParameterSet names to be read, in this order + parameterSets = cms.vstring('pythiaUESettings', + 'processParameters') + ) +) + +configurationMetadata = cms.untracked.PSet( + version = cms.untracked.string('$Revision: 1.1 $'), + name = cms.untracked.string('$Source: /cvs/CMSSW/CMSSW/Configuration/GenProduction/python/ThirteenTeV/WH_ZH_HToTauTau_M_125_TuneZ2star_13TeV_pythia6_cff.py,v $'), + annotation = cms.untracked.string('PYTHIA6 WH/ZH, H->2tau mH=125GeV with TAUOLA at 13TeV') +) diff --git a/AnalysisSpace/TreeMaker/test/miniAOD-prod_PAT.py b/AnalysisSpace/TreeMaker/test/miniAOD-prod_PAT.py new file mode 100644 index 0000000..3654a53 --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/miniAOD-prod_PAT.py @@ -0,0 +1,91 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: miniAOD-prod -s PAT --eventcontent MINIAODSIM --runUnscheduled --mc --filein /store/relval/CMSSW_7_0_0/RelValTTbar_13/GEN-SIM-RECO/PU50ns_POSTLS170_V4-v2/00000/265B9219-FF98-E311-BF4A-02163E00EA95.root --conditions PLS170_V6AN1::All --no_exec +import FWCore.ParameterSet.Config as cms + +process = cms.Process('PAT') + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_cfi') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.StandardSequences.MagneticField_38T_cff') +process.load('Configuration.StandardSequences.PATMC_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1) +) + +# Input source +process.source = cms.Source("PoolSource", + secondaryFileNames = cms.untracked.vstring(), + fileNames = cms.untracked.vstring('/store/relval/CMSSW_7_0_0/RelValTTbar_13/GEN-SIM-RECO/PU50ns_POSTLS170_V4-v2/00000/265B9219-FF98-E311-BF4A-02163E00EA95.root') +) + +process.options = cms.untracked.PSet( + allowUnscheduled = cms.untracked.bool(True) +) + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + version = cms.untracked.string('$Revision: 1.19 $'), + annotation = cms.untracked.string('miniAOD-prod nevts:1'), + name = cms.untracked.string('Applications') +) + +# Output definition + +process.MINIAODSIMoutput = cms.OutputModule("PoolOutputModule", + compressionLevel = cms.untracked.int32(4), + compressionAlgorithm = cms.untracked.string('LZMA'), + eventAutoFlushCompressedSize = cms.untracked.int32(15728640), + outputCommands = process.MINIAODSIMEventContent.outputCommands, + fileName = cms.untracked.string('miniAOD-prod_PAT.root'), + dataset = cms.untracked.PSet( + filterName = cms.untracked.string(''), + dataTier = cms.untracked.string('') + ), + dropMetaData = cms.untracked.string('ALL'), + fastCloning = cms.untracked.bool(False), + overrideInputFileSplitLevels = cms.untracked.bool(True) +) + +# Additional output definition + +# Other statements +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'PLS170_V6AN1::All', '') + +# Path and EndPath definitions +process.Flag_trackingFailureFilter = cms.Path(process.goodVertices+process.trackingFailureFilter) +process.Flag_goodVertices = cms.Path(process.goodVertices) +process.Flag_CSCTightHaloFilter = cms.Path(process.CSCTightHaloFilter) +process.Flag_trkPOGFilters = cms.Path(process.trkPOGFilters) +process.Flag_trkPOG_logErrorTooManyClusters = cms.Path(~process.logErrorTooManyClusters) +process.Flag_EcalDeadCellTriggerPrimitiveFilter = cms.Path(process.EcalDeadCellTriggerPrimitiveFilter) +process.Flag_ecalLaserCorrFilter = cms.Path(process.ecalLaserCorrFilter) +process.Flag_trkPOG_manystripclus53X = cms.Path(~process.manystripclus53X) +process.Flag_eeBadScFilter = cms.Path(process.eeBadScFilter) +process.Flag_METFilters = cms.Path(process.metFilters) +process.Flag_HBHENoiseFilter = cms.Path(process.HBHENoiseFilter) +process.Flag_trkPOG_toomanystripclus53X = cms.Path(~process.toomanystripclus53X) +process.Flag_hcalLaserEventFilter = cms.Path(process.hcalLaserEventFilter) +process.endjob_step = cms.EndPath(process.endOfProcess) +process.MINIAODSIMoutput_step = cms.EndPath(process.MINIAODSIMoutput) + +# customisation of the process. + +# Automatic addition of the customisation function from PhysicsTools.PatAlgos.slimming.miniAOD_tools +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC + +#call to customisation function miniAOD_customizeAllMC imported from PhysicsTools.PatAlgos.slimming.miniAOD_tools +process = miniAOD_customizeAllMC(process) + +# End of customisation functions diff --git a/AnalysisSpace/TreeMaker/test/pat.py b/AnalysisSpace/TreeMaker/test/pat.py new file mode 100644 index 0000000..3604598 --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/pat.py @@ -0,0 +1,95 @@ +## import skeleton process +from PhysicsTools.PatAlgos.patTemplate_cfg import * + +# verbose flags for the PF2PAT modules +process.options.allowUnscheduled = cms.untracked.bool(True) +#process.Tracer = cms.Service("Tracer") + +runOnMC = True + +if runOnMC: + from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValProdTTbarAODSIM + process.source.fileNames = filesRelValProdTTbarAODSIM +else: + from PhysicsTools.PatAlgos.patInputFiles_cff import filesSingleMuRECO + process.source.fileNames = filesSingleMuRECO + process.GlobalTag.globaltag = cms.string( autoCond[ 'com10' ] ) + +# load the PAT config (for the PAT only part) +#process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") +#process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff") +process.load("PhysicsTools.PatAlgos.patSequences_cff") + +from PhysicsTools.PatAlgos.tools.metTools import addMETCollection +addMETCollection(process, labelName='patMETsTypeIcorrected', metSource='pfType1CorrectedMet') +addMETCollection(process, labelName='patMETTC', metSource='tcMet') + +# An empty postfix means that only PF2PAT is run, +# otherwise both standard PAT and PF2PAT are run. In the latter case PF2PAT +# collections have standard names + postfix (e.g. patElectronPFlow) +postfix = "" +jetAlgo = "AK5" +#Define Objects to be excluded from Top Projection. Default is Tau, so objects are not cleaned for taus +excludeFromTopProjection=['Tau'] + +# Configure PAT to use PF2PAT instead of AOD sources +# this function will modify the PAT sequences. +from PhysicsTools.PatAlgos.tools.pfTools import * +usePF2PAT(process,runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=postfix,excludeFromTopProjection=excludeFromTopProjection) +# to run second PF2PAT+PAT with different postfix uncomment the following lines +# and add the corresponding sequence to path +#postfix2 = "PFlow2" +#jetAlgo2="AK7" +#usePF2PAT(process,runPF2PAT=True, jetAlgo=jetAlgo2, runOnMC=True, postfix=postfix2) + +# to use tau-cleaned jet collection uncomment the following: +#getattr(process,"pfNoTau"+postfix).enable = True + +if not runOnMC: + # removing MC matching for standard PAT sequence + # for the PF2PAT+PAT sequence, it is done in the usePF2PAT function + removeMCMatchingPF2PAT( process, '' ) + +# Add PF2PAT output to the created file +from PhysicsTools.PatAlgos.patEventContent_cff import \ +patEventContentNoCleaning,patExtraAodEventContent,patTriggerEventContent,patTriggerL1RefsEventContent,patEventContentTriggerMatch +process.out.outputCommands.extend(patExtraAodEventContent) +process.out.outputCommands.extend(patTriggerEventContent) +process.out.outputCommands.extend(patTriggerL1RefsEventContent) +process.out.outputCommands.extend(patEventContentTriggerMatch) +process.out.outputCommands.extend(['drop recoGenJets_*_*_*']) +process.out.outputCommands.extend(['keep recoVertexs_goodOfflinePrimaryVertices_*_*', + 'keep recoPFCandidates_particleFlow_*_*', + 'keep PileupSummaryInfos_*_*_*', + 'keep recoVertexs_goodOfflinePrimaryVertices_*_*', + 'keep *_offlineBeamSpot_*_*', + 'keep L1GlobalTriggerReadoutRecord_*_*_*', + 'keep *_ak5GenJets_*_*', + 'keep *_kt6GenJets_*_*', + 'keep *_genMetTrue_*_*', + #'keep *_kt6PFJets_*_*', + 'keep recoPFJets_ak5PFJets_*_*', + 'keep *_*GsfElectrons*_*_*', + 'keep *_electronGsfTracks_*_*']) +process.p = cms.Path( + process.patDefaultSequence +) + +## ------------------------------------------------------ +# In addition you usually want to change the following +# parameters: +## ------------------------------------------------------ +# +# process.GlobalTag.globaltag = ... ## (according to https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideFrontierConditions) +# ## +# process.source.fileNames = ... ## (e.g. 'file:AOD.root') +# +process.maxEvents.input = 10 +# ## +# process.out.outputCommands = [ ... ] ## (e.g. taken from PhysicsTools/PatAlgos/python/patEventContent_cff.py) +# ## +process.out.fileName = 'patTuple_PATandPF2PAT.root' +# ## +# process.options.wantSummary = False ## (to suppress the long output at the end of the job) + +#process.prune(verbose=True) diff --git a/AnalysisSpace/TreeMaker/test/test.py b/AnalysisSpace/TreeMaker/test/test.py new file mode 100644 index 0000000..0f6f438 --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/test.py @@ -0,0 +1,92 @@ +import FWCore.ParameterSet.Config as cms +process = cms.Process("TreeMaker") +#------------------------ +# Message Logger Settings +#------------------------ +process.load("FWCore.MessageLogger.MessageLogger_cfi") +process.MessageLogger.cerr.FwkReport.reportEvery = 1 +process.MessageLogger.infos.threshold = cms.untracked.string("ERROR") +#-------------------------------------- +# Event Source & # of Events to process +#--------------------------------------- +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring() +) +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(10) +) +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False) ) + +#----------------------------- +# Geometry +#----------------------------- +process.load("Configuration.StandardSequences.Geometry_cff") +#----------------------------- +# Magnetic Field +#----------------------------- +process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff') +#------------- +# Global Tag +#------------- +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process.GlobalTag.globaltag = 'START71_V1::All' + +#------------- +# Output ROOT file +#------------- +process.TFileService = cms.Service("TFileService", + fileName = cms.string('test.root') +) +#-------------------------------------------------- +# Analysis Tree Specific +#-------------------------------------------------- +process.load("AnalysisSpace.TreeMaker.TreeCreator_cfi") +process.load("AnalysisSpace.TreeMaker.TreeWriter_cfi") +process.load("AnalysisSpace.TreeMaker.TreeContentConfig_cff") + +# Primary Vertex Selector +process.selectedPrimaryVertices = cms.EDFilter("VertexSelector", + src = cms.InputTag('offlineSlimmedPrimaryVertices'), + cut = cms.string("isValid & ndof >= 4 & chi2 > 0 & tracksSize > 0 & abs(z) < 24 & abs(position.Rho) < 2.0"), + filter = cms.bool(True) +) + +# Sequence for rhoNeutral +from CommonTools.ParticleFlow.ParticleSelectors.pfAllNeutralHadrons_cfi import pfAllNeutralHadrons +from CommonTools.ParticleFlow.ParticleSelectors.pfAllPhotons_cfi import pfAllPhotons +pfNeutralCandPdgIds = [] +pfNeutralCandPdgIds.extend(pfAllNeutralHadrons.pdgId.value()) +pfNeutralCandPdgIds.extend(pfAllPhotons.pdgId.value()) + +process.pfNeutralCands = cms.EDFilter("PdgIdPFCandidateSelector", + src = cms.InputTag('particleFlow'), + pdgId = cms.vint32(pfNeutralCandPdgIds) +) +from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets +process.kt6PFNeutralJetsForVtxMultReweighting = kt4PFJets.clone( + src = cms.InputTag('pfNeutralCands'), + rParam = cms.double(0.6), + doRhoFastjet = cms.bool(True), + Rho_EtaMax = cms.double(2.5) +) +process.kt6PFJets = kt4PFJets.clone( + rParam = cms.double(0.6), + doRhoFastjet = cms.bool(True), + Rho_EtaMax = cms.double(2.5) +) + +process.p = cms.Path( + #process.selectedPrimaryVertices * + #process.kt6PFJets* + #process.pfNeutralCands * + #process.kt6PFNeutralJetsForVtxMultReweighting* + process.treeCreator* + process.treeContentSequence* + process.treeWriter +) + +# List File names here +#--------------------------------------- +process.PoolSource.fileNames = [ + 'root://cms-xrd-global.cern.ch//store/mc/Spring14miniaod/TTJets_MSDecaysCKM_central_Tune4C_13TeV-madgraph-tauola/MINIAODSIM/PU20bx25_POSTLS170_V5-v1/00000/F6EDDC10-8DFC-E311-BC5D-0025905A60D6.root' +] diff --git a/AnalysisSpace/TreeMaker/test/tmp.txt b/AnalysisSpace/TreeMaker/test/tmp.txt new file mode 100644 index 0000000..3f6d93e --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/tmp.txt @@ -0,0 +1,2972 @@ +19-Sep-2014 22:09:56 CEST Initiating request to open file root://cms-xrd-global.cern.ch//store/mc/Spring14miniaod/TTJets_MSDecaysCKM_central_Tune4C_13TeV-madgraph-tauola/MINIAODSIM/PU20bx25_POSTLS170_V5-v1/00000/F6EDDC10-8DFC-E311-BC5D-0025905A60D6.root +19-Sep-2014 22:09:57 CEST Successfully opened file root://cms-xrd-global.cern.ch//store/mc/Spring14miniaod/TTJets_MSDecaysCKM_central_Tune4C_13TeV-madgraph-tauola/MINIAODSIM/PU20bx25_POSTLS170_V5-v1/00000/F6EDDC10-8DFC-E311-BC5D-0025905A60D6.root +hltPattern = + +HLT_(Mu\d{1,2}_Ele\d{1,2}_(?:Calo)? | +Ele[1-4][0-9] | +[^(QuadJet\d+_)]IsoPFTau) + +TStorageFactoryFile** test.root + TStorageFactoryFile* test.root + TDirectoryFile* treeCreator treeCreator + OBJ: TTree vhtree Physics Analysis Level TTree : 0 at: 0x7fd791b26a00 + KEY: TDirectoryFile treeCreator;1 treeCreator +Begin processing the 1st record. Run 1, Event 7002001, LumiSection 70021 at 19-Sep-2014 22:10:03.955 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:03 CEST Run: 1 Event: 7002001 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:03 CEST Run: 1 Event: 7002001 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional + Paths (0/0): Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltTripleL2Jets30eta3 + Paths (3/1): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_QuadJet45_v1(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltTripleL2Jets30eta3 + Paths (3/1): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_QuadJet45_v1(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltTripleL2Jets30eta3 + Paths (3/1): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_QuadJet45_v1(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBJet20L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadJet25HbbZbb hltTripleL2Jets30eta3 + Paths (2/1): HLT_QuadJet45_v1(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltL1FastJetQuad18HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltL1FastJetQuad18HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltL1FastJetQuad18HbbVBF + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltDiJetBLifetimeL3FilterHbbZbbCSV hltSingleJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV05 + Paths (2/0): HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltBLifetimeL3FilterbbPhi1BLooseL1FastJetFastPV hltDiJetBLifetimeL3FilterHbbZbbCSV hltSingleJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV05 + Paths (2/1): HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) Collection: hltPFHT350MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT350MET100orMHT150 + Paths (0/0): Collection: hltPFHT350MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT350MET100orMHT150 + Paths (0/0): Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (1/1): HLT_PFNoPUHT350_v5(L,3) Collection: hltPFHT400MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT400MET100orMHT150 + Paths (0/0): Collection: hltPFHT400MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT400MET100orMHT150 + Paths (0/0): Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (19/11): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_AlphaT0p55_v8(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_QuadJet45_v1(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (19/11): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_AlphaT0p55_v8(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_QuadJet45_v1(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (19/11): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_AlphaT0p55_v8(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_QuadJet45_v1(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (12/6): HLT_HcalNZS_v10(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_QuadJet45_v1(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleForJet16EtaOpp hltL1sL1SingleForJet16 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF + Paths (9/5): HLT_HcalNZS_v10(L,3) HLT_DoubleJet20_ForwardBackward_v4(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleForJet16EtaOpp hltL1sL1SingleForJet16 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF + Paths (9/5): HLT_HcalNZS_v10(L,3) HLT_DoubleJet20_ForwardBackward_v4(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1DoubleForJet16EtaOpp hltL1sL1SingleForJet16 hltL1sL1SingleJet16 hltL1sL1SingleJet36 + Paths (9/5): HLT_HcalNZS_v10(L,3) HLT_DoubleJet20_ForwardBackward_v4(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1DoubleForJet16EtaOpp hltL1sL1SingleForJet16 hltL1sL1SingleJet16 + Paths (6/4): HLT_HcalNZS_v10(L,3) HLT_DoubleJet20_ForwardBackward_v4(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -87 + Filters: hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1ETM30 hltL1sL1ETM36ORETM40 hltL1sL1ETM36ORETM40ORETM50 hltL1sL1ETM36or40 hltL1sL1ETM40 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 + Paths (2/2): HLT_L1ETM30_v2(L,3) HLT_L1ETM40_v2(L,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (2/2): HLT_PixelTracks_Multiplicity80_v13(L,3) HLT_PixelTracks_Multiplicity70_v4(L,3) Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu4HTT125 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (8/6): HLT_PFNoPUHT350_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_AlphaT0p55_v8(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_QuadJet45_v1(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJet80HbbZbb hltDiPFJetAve40 hltDiPFJetAve80 hltQuadPFJet30HbbZbb + Paths (3/3): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJet80HbbZbb hltDiPFJetAve40 hltDiPFJetAve80 hltQuadPFJet30HbbZbb + Paths (3/3): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJet80HbbZbb hltQuadPFJet30HbbZbb + Paths (1/1): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltQuadPFJet30HbbZbb + Paths (1/1): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackPt1MediumIsolation::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolation hltDoublePFTau35TrackPt1MediumIsolation + Paths (0/0): Collection: hltSelectedPFTausTrackPt1MediumIsolationReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolationReg hltDoublePFTau35TrackPt1MediumIsolationReg + Paths (0/0): Collection: hltSelectedPFTausTrackPt1Reg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1Reg hltDoublePFTau35TrackPt1Reg + Paths (0/0): Collection: hltSelectedPFTausTrackPt1Reg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1Reg hltDoublePFTau35TrackPt1Reg + Paths (0/0): Collection: hltSelectedPFTausTrackPt1Reg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1Reg hltDoublePFTau35TrackPt1Reg + Paths (0/0): Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (0/0): Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (0/0): Collection: hltSelectedPFTausTrackPt20Isolation::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20LooseIso + Paths (0/0): Collection: hltSelectedPFTausTrackPt20Isolation::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20LooseIso + Paths (0/0): indx x y z rho chi2 ndf + 0 0.24 0.39 0.39 0.46 1.2e+02 1.8e+02 + 1 0.25 0.39 0.39 0.46 94 1.4e+02 + 2 0.24 0.39 0.39 0.46 1.6e+02 1.6e+02 + 3 0.25 0.4 0.4 0.47 1.1e+02 1.2e+02 + 4 0.24 0.4 0.4 0.47 28 27 + 5 0.25 0.39 0.39 0.46 60 83 + 6 0.24 0.4 0.4 0.46 53 76 + 7 0.24 0.39 0.39 0.46 23 42 + 8 0.25 0.39 0.39 0.46 33 51 + 9 0.26 0.38 0.38 0.46 0.94 2.9 + 10 0.24 0.39 0.39 0.46 11 12 + 11 0.24 0.4 0.4 0.47 8.5 15 + 12 0.23 0.38 0.38 0.44 46 32 + 13 0.24 0.39 0.39 0.45 16 19 + 14 0.25 0.4 0.4 0.47 6 5.6 + 15 0.25 0.41 0.41 0.48 3.7 6.7 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002001 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 2nd record. Run 1, Event 7002005, LumiSection 70021 at 19-Sep-2014 22:10:04.616 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002005 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002005 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltL2MuonCandidates::HLT + Type IDs: 83 + Filters: hltL1HTT150singleMuL2PreFiltered0 hltL1HTT150singleMuL2PreFiltered10 hltL1Mu0EG5L2MuFiltered0 hltL1Mu0HTT100L2Filtered0 hltL1Mu0HTT100ORL1Mu4HTT125L2QualMuFiltered16 hltL1Mu0HTT100ORMu4HTT125L2Filtered0 hltL1Mu12EG7ORL1MuOpenEG12L2MuFiltered0 hltL1Mu3p5EG12L2Filtered12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L2Filtered5 hltL2fL1sMu3L2Filtered3 hltMu5TrackJpsiL2Filtered3 hltSingleMuOpenCandidateL2Filtered0 hltSingleMuOpenCandidateL2Filtered3 + Paths (3/0): HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) DST_Mu5_HT250_v5(*,3) Collection: hltL3MuonCandidates::HLT + Type IDs: 83 + Filters: hltL1HTT150singleMuL3PreFiltered15 hltL1HTT150singleMuL3PreFiltered5 hltL1Mu0EG5L3MuFiltered7 hltL1Mu0HTT100L3Filtered5 hltL1Mu0HTT100ORMu4HTT125L3Filtered8 hltL1Mu12EG7ORL1MuOpenEG12L3MuFiltered14 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L3Filtered8 hltL3fL1sMu3L3Filtered5 hltL3fL1sMu3L3Filtered8 hltMu5Track1JpsiPixelMassFiltered hltMu5TrackJpsiL3Filtered3 hltSingleMuOpenCandidateL3Filtered12 hltSingleMuOpenCandidateL3Filtered5 + Paths (3/3): HLT_Mu5_v21(L,3) HLT_Mu8_v19(L,3) DST_Mu5_HT250_v5(L,3) Collection: hltBSoftMuonDiJet20L1FastJetL25Jets::HLT + Type IDs: 86 + Filters: hltBSoftMuonDiJet20L1FastJetMu5L3FilterByDR + Paths (1/1): HLT_BTagMu_DiJet20_Mu5_v7(L,3) Collection: hltBSoftMuonDiJet40L1FastJetL25Jets::HLT + Type IDs: 86 + Filters: hltBSoftMuonDiJet40L1FastJetMu5L3FilterByDR + Paths (1/1): HLT_BTagMu_DiJet40_Mu5_v7(L,3) Collection: hltBSoftMuonDiJet70L1FastJetL25Jets::HLT + Type IDs: 86 + Filters: hltBSoftMuonDiJet70L1FastJetMu5L3FilterByDR + Paths (1/1): HLT_BTagMu_DiJet70_Mu5_v7(L,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (0/0): Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (13/9): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (13/9): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (12/9): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (12/9): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltSingleBJet60Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (10/8): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltSingleBJet60Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (10/8): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltQuadJet25HbbZbb hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (4/3): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltQuadJet25HbbZbb hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (4/3): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltQuadJet25HbbZbb hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (4/3): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (2/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (2/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (2/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (2/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltBLifetimeL3FilterbbPhi1BLooseL1FastJetFastPV hltDiJetBLifetimeL3FilterHbbZbbCSV hltSingleJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV05 + Paths (1/1): HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(L,3) Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (1/1): HLT_PFNoPUHT350_v5(L,3) Collection: hltPFHT350PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT350PFMET45 + Paths (0/0): Collection: hltPFHT350PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT350PFMET50 + Paths (0/0): Collection: hltPFHT400PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET45 + Paths (0/0): Collection: hltPFHT400PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET50 + Paths (0/0): Collection: hltHITIPTCorrectorHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL3FilterHB + Paths (1/1): HLT_IsoTrackHB_v15(L,3) Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (1/0): HLT_IsoTrackHB_v15(*,3) Collection: hltIsolPixelTrackProdHE::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHE + Paths (0/0): Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1Mu0EG5 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1SingleEG12 hltL1sL1SingleEG20ORL1SingleEG22 hltL1sL1SingleEG22 hltL1sL1SingleEG24 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1SingleIsoEG18erORIsoEG20erOREG22 hltL1sL1TripleEG7 + Paths (4/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_L1SingleEG12_v6(L,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1Mu0EG5 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1SingleEG12 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1TripleEG7 + Paths (4/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_L1SingleEG12_v6(L,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1Mu0EG5 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1TripleEG7 + Paths (3/3): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (26/13): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_AlphaT0p57_v8(L,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (26/13): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_AlphaT0p57_v8(L,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (29/13): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_AlphaT0p57_v8(L,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (29/13): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_AlphaT0p57_v8(L,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (2/2): HLT_PixelTracks_Multiplicity80_v13(L,3) HLT_PixelTracks_Multiplicity70_v4(L,3) Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sAlCaEcalPi0Eta hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (18/7): HLT_PFNoPUHT350_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_QuadJet70_v6(*,3) HLT_SixJet35_v6(*,3) HLT_SixJet45_v6(*,3) HLT_SixJet50_v6(*,3) HLT_EightJet30_eta3p0_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve40 hltDiPFJetAve80 + Paths (2/2): HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve40 hltDiPFJetAve80 + Paths (2/2): HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltL1JetsHLTDoublePFTauTrackPt1MediumIsolationProng4Match::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolationProng4L1HLTMatched + Paths (0/0): Collection: hltL1JetsHLTDoublePFTauTrackPt1MediumIsolationProng4Match::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolationProng4L1HLTMatched + Paths (0/0): Collection: hltL1JetsHLTDoublePFTauTrackPt1MediumIsolationProng4MatchReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolationProng4L1HLTMatchedReg + Paths (0/0): Collection: hltL1JetsHLTDoublePFTauTrackPt1MediumIsolationProng4MatchReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolationProng4L1HLTMatchedReg + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackPt1MediumIsolation::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolation + Paths (0/0): Collection: hltSelectedPFTausTrackPt1MediumIsolation::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolation hltDoublePFTau35TrackPt1MediumIsolation + Paths (0/0): Collection: hltSelectedPFTausTrackPt1MediumIsolationProng4::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolationProng4 + Paths (0/0): indx x y z rho chi2 ndf + 0 0.24 0.39 0.39 0.46 1.8e+02 2e+02 + 1 0.24 0.39 0.39 0.46 31 45 + 2 0.24 0.39 0.39 0.46 60 69 + 3 0.24 0.39 0.39 0.46 20 30 + 4 0.24 0.4 0.4 0.47 11 18 + 5 0.25 0.39 0.39 0.46 25 30 + 6 0.25 0.39 0.39 0.46 17 14 + 7 0.24 0.39 0.39 0.46 42 47 + 8 0.25 0.39 0.39 0.46 15 12 + 9 0.24 0.39 0.39 0.46 6 6.5 + 10 0.25 0.4 0.4 0.47 18 18 + 11 0.25 0.38 0.38 0.46 2.2 6.8 + 12 0.24 0.38 0.38 0.45 10 13 + 13 0.23 0.4 0.4 0.46 2.8 8.8 + 14 0.22 0.38 0.38 0.44 1 2.9 + 15 0.17 0.43 0.43 0.46 4.5 2.6 + 16 0.23 0.41 0.41 0.47 2.2 2.8 + 17 0.26 0.4 0.4 0.47 0.79 2.9 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002005 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 3rd record. Run 1, Event 7002009, LumiSection 70021 at 19-Sep-2014 22:10:04.627 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002009 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002009 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltL1SeededRecoEcalCandidate::HLT + Type IDs: 81 92 + Filters: hltEG20CaloIdVLHEFilter hltEG30CaloIdVLHEFilter hltEG30CaloIdVTHEFilterL1EG22 hltEG36HE10LastFilter hltEG40CaloIdLHEFilter hltEle13WP90ClusterShapeFilter hltEle13WP90NoIsoHEFilter hltEle13WP90NoIsoPixelMatchFilter hltEle17CaloIdLCaloIsoVLPixelMatchFilter hltEle22CaloIdLCaloIsoVLPixelMatchFilter hltEle22WP90NoIsoHEFilter hltEle22WP90NoIsoPixelMatchFilter hltEle22WP90RhoClusterShapeFilter hltEle33CaloIdLPixelMatchFilter hltEle33CaloIdTPixelMatchFilter hltEle8CaloIdLCaloIsoVLPixelMatchFilter hltMu22Photon22CaloIdLHEFilter hltMu3p5Ele30CaloIdLPixelMatchFilter hltMu3p5Photon30CaloIdLHEFilter hltMu7Ele7CaloIdTPixelMatchFilter hltPhoton30HEFilter hltSingleEle13WP90RhoClusterShapeFilter + Paths (18/9): HLT_Photon20_CaloIdVL_v5(L,3) HLT_Photon30_CaloIdVL_v15(L,3) HLT_Ele30_CaloIdVT_TrkIdT_v7(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet150_PFNoPUJet25_v9(*,3) HLT_Photon36_Photon22_v7(*,3) HLT_DoublePhoton40_CaloIdL_Rsq0p035_v7(*,3) HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(*,3) HLT_Ele17_CaloIdL_CaloIsoVL_v18(L,3) HLT_Ele22_CaloIdL_CaloIsoVL_v7(L,3) HLT_Ele22_eta2p1_WP90NoIso_LooseIsoPFTau20_v8(*,3) HLT_DoubleEle33_CaloIdL_v15(*,3) HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v8(*,3) HLT_Ele8_CaloIdL_CaloIsoVL_v18(L,3) HLT_Mu22_Photon22_CaloIdL_v8(L,3) HLT_Mu30_Ele30_CaloIdL_v9(L,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(L,3) HLT_Photon30_v2(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 81 92 + Filters: hltDiEle33CaloIdLGsfTrkIdVLDPhiDoubleFilter hltDiEle33CaloIdLPixelMatchDoubleFilter hltEG22HE10DoubleLastFilterUnseeded hltEG40CaloIdLHEDoubleFilterUnseeded hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (5/4): HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v8(L,3) HLT_DoubleEle33_CaloIdL_v15(L,3) HLT_Photon36_Photon22_v7(L,3) HLT_DoublePhoton40_CaloIdL_Rsq0p035_v7(*,3) HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 81 92 + Filters: hltDiEle33CaloIdLGsfTrkIdVLDPhiDoubleFilter hltDiEle33CaloIdLPixelMatchDoubleFilter hltEG22HE10DoubleLastFilterUnseeded hltEG40CaloIdLHEDoubleFilterUnseeded hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (5/4): HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v8(L,3) HLT_DoubleEle33_CaloIdL_v15(L,3) HLT_Photon36_Photon22_v7(L,3) HLT_DoublePhoton40_CaloIdL_Rsq0p035_v7(*,3) HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltPixelMatch3HitElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltEle8TightIdLooseIsoTrackIsoFilter hltMu17Ele8CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltMu8Ele17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter + Paths (6/4): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v7(L,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(L,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(L,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(L,3) Collection: hltPixelMatchElectronsActivity::HLT + Type IDs: 82 + Filters: hltEle12CaloIdTTrkIdVLCaloIsoVLTrkIsoVLTrackIsoFilterUnseeded hltEle15CaloIdTTrkIdTCaloIsoVLTrkIsoVLFilterUnseeded hltEle5CaloIdTTrkIdTCaloIsoVLTrkIsoVLFilterUnseeded hltEle8CaloIdLTrkIdVLCaloIsoVLTrkIsoVLTrackIsolFilterUnseeded hltL1Mu0HTT100Mu5Ele8CaloIdTTrkIdVLMass8Filter hltL1Mu4HTT125Mu5Ele8CaloIdTTrkIdVLMass8Filter hltMu8Ele8CaloIdTTrkIdVLMass8Filter hltSingleElectronEt8CaloIdTTrkIdVLNoCandDphiFilter + Paths (12/4): HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR30_Rsq0p04_MR200_v5(L,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR40_Rsq0p04_MR200_v5(L,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(L,3) HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v4(*,3) HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v4(*,3) HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v4(*,3) HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v4(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(L,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) Collection: hltPixelMatchElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle13WP90NoIsoDetaFilter hltEle13WP90NoIsoDphiFilter hltEle13WP90NoIsoOneOEMinusOneOPFilter hltEle14CaloIdTTrkIdVLDphiFilter hltEle22WP90NoIsoDetaFilter hltEle22WP90NoIsoDphiFilter hltEle22WP90NoIsoOneOEMinusOneOPFilter hltEle25CaloIdVTTrkIdVLCaloIsoVLTrkIsoTTrackIsoFilter hltEle27CaloIdLCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltEle30CaloIdVTTrkIdTDphiFilter hltEle32CaloIdLCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltEle8CaloIdTTrkIdTL1EG8DoubleJet20CentralDphiFilter hltEle8CaloIdTTrkIdVLDphiFilter hltEle8CaloIdTTrkIdVLEG7DphiFilter hltMu14Ele14CaloIdTTrkIdVLMass8Filter hltOverlapFilterEle13WP90LooseIsoPFTau20 hltOverlapFilterEle20LooseIsoPFTau20 + Paths (18/7): HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(L,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET40_v9(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET50_v9(*,3) HLT_Ele22_eta2p1_WP90NoIso_LooseIsoPFTau20_v8(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(*,3) HLT_Ele27_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(L,3) HLT_Ele30_CaloIdVT_TrkIdT_v7(L,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet150_PFNoPUJet25_v9(*,3) HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdVL_v6(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(*,3) HLT_Ele8_CaloIdT_TrkIdVL_EG7_v3(L,3) Collection: hltL2MuonCandidates::HLT + Type IDs: 83 + Filters: hltL1HTT150singleMuL2PreFiltered0 hltL1HTT150singleMuL2PreFiltered10 hltL1Mu0EG5L2MuFiltered0 hltL1Mu0HTT100L2Filtered0 hltL1Mu0HTT100ORL1Mu4HTT125L2QualMuFiltered16 hltL1Mu0HTT100ORMu4HTT125L2Filtered0 hltL1Mu12EG7L2MuFiltered0 hltL1Mu12EG7ORL1MuOpenEG12L2MuFiltered0 hltL1Mu3p5EG12L2Filtered12 hltL1Mu4HTT125L2Filtered0 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L2Filtered5 hltL2L1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL2MuFiltered10Eta2p1 hltL2fL1sMu12Eta2p1L1f0L2Filtered12Q hltL2fL1sMu12L2Filtered12 hltL2fL1sMu14Eta2p1L1f0L2Filtered14Q hltL2fL1sMu14erORMu16erL1f0L2Filtered14Q hltL2fL1sMu16Eta2p1L1f0L2Filtered16Q hltL2fL1sMu16Eta2p4L1f0L2Filtered16Q hltL2fL1sMu16L1f0L2Filtered16Q hltL2fL1sMu16erL2Filtered16 hltL2fL1sMu3L2Filtered3 hltL2fL1sMu7Eta2p1L1f0L2Filtered7Q hltL2fL1sMu7L1fEta2p1L2FilteredEta2p1Filtered7 hltL2fL1sMu7L2Filtered7 hltL2fL1sSingleMu7Eta2p1L1f0L2Filtered7Q hltMu15TkMu5DCAL2Filtered10 hltMu5TrackJpsiL2Filtered3 hltSingleMuOpenCandidateL2Filtered0 hltSingleMuOpenCandidateL2Filtered3 + Paths (71/0): HLT_PFNoPUHT400_Mu5_PFMET45_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET50_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET45_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET50_v5(*,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET40_v9(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET50_v9(*,3) HLT_Mu30_Ele30_CaloIdL_v9(*,3) HLT_Mu22_Photon22_CaloIdL_v8(*,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_IsoMu15_eta2p1_L1ETM20_v8(*,3) HLT_IsoMu15_eta2p1_LooseIsoPFTau35_Trk20_Prong1_L1ETM20_v11(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) HLT_Mu17_v6(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(*,3) HLT_Mu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v8(*,3) HLT_Mu17_eta2p1_LooseIsoPFTau20_v8(*,3) HLT_Mu24_eta2p1_v6(*,3) HLT_Mu30_eta2p1_v6(*,3) HLT_Mu40_eta2p1_v12(*,3) HLT_Mu50_eta2p1_v9(*,3) HLT_IsoMu20_eta2p1_v8(*,3) HLT_IsoMu24_eta2p1_v16(*,3) HLT_IsoMu30_eta2p1_v16(*,3) HLT_IsoMu34_eta2p1_v14(*,3) HLT_IsoMu40_eta2p1_v11(*,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(*,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_PFMET20_v2(*,3) HLT_Mu24_v17(*,3) HLT_Mu30_v17(*,3) HLT_Mu40_v15(*,3) HLT_IsoMu24_v18(*,3) HLT_IsoMu30_v12(*,3) HLT_RelIso1p0Mu20_v4(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_RelIso1p0Mu5_v7(*,3) HLT_IsoMu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu15_eta2p1_v6(*,3) HLT_Mu12_v19(*,3) HLT_IsoMu8_eta2p1_LooseIsoPFTau20_v2(*,3) DST_Mu5_HT250_v5(*,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) Collection: hltL2MuonCandidatesNoVtx::HLT + Type IDs: 83 + Filters: hltL2fL1sMu16Eta2p1L1f0L2Filtered20 + Paths (1/1): HLT_L2Mu20_eta2p1_NoVertex_v2(L,3) Collection: hltL3MuonCandidates::HLT + Type IDs: 83 + Filters: hltL1HTT150singleMuL3PreFiltered15 hltL1HTT150singleMuL3PreFiltered5 hltL1Mu0EG5L3MuFiltered7 hltL1Mu0HTT100L3Filtered5 hltL1Mu0HTT100L3RelIso1p0MuonIsoFilter hltL1Mu0HTT100Mu5Ele8CaloIdTTrkIdVLMass8Filter hltL1Mu0HTT100ORL1Mu4HTT125L2QualL3MuFiltered40 hltL1Mu0HTT100ORMu4HTT125L3Filtered8 hltL1Mu10Eta2p1Jet20Jet12CentralCorrOrMu10erJetC32OrMu12erOrMu14erL3Mufiltered15Eta2p1 hltL1Mu12EG7L3MuFiltered17 hltL1Mu12EG7ORL1MuOpenEG12L3MuFiltered14 hltL1Mu3p5EG12L3Filtered22 hltL1Mu3p5EG12L3Filtered30 hltL1Mu4HTT125L3Filtered5 hltL1Mu4HTT125L3RelIso1p0MuonIsoFilter hltL1Mu4HTT125Mu5Ele8CaloIdTTrkIdVLMass8Filter hltL1sL1Mu3p5EG12ORL1MuOpenEG12L3Filtered8 hltL3L1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL3Mufiltered12Eta2p1 hltL3Mu8DoubleJetC20L3Filtered8 hltL3crIsoL1sMu12Eta2p1L1f0L2f12QL3f15QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu14Eta2p1L1f0L2f16QL3f20L3crIsoRhoFiltered0p15 hltL3crIsoL1sMu14erORMu16erL1f0L2f14QL3f17QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f18QL3crIsoFiltered10 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f18QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f20L3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f20QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f30QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f34QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f40QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p4L1f0L2f16QL3f18QL3crIsoFiltered10 hltL3crIsoL1sMu16L1f0L2f16QL3f20QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16L1f0L2f16QL3f30QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu7Eta2p1L1f0L2f7QL3f8QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMuOpenCandidateL1f0L2f3L3f12L3crIsoFiltered12 hltL3crIsoL1sSingleMu7Eta2p1L1f0L2f7QL3f8QL3crIsoRhoFiltered0p15 hltL3fL1sMu12Eta2p1L1f0L2f12QL3Filtered15Q hltL3fL1sMu12L3Filtered17 hltL3fL1sMu14erORMu16erL1f0L2f14QL3Filtered17Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered18Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered24Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered30Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered34Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered40 hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered40Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered50Q hltL3fL1sMu16Eta2p4L1f0L2f16QL3Filtered18Q hltL3fL1sMu16L1f0L2f16QL3Filtered20Q hltL3fL1sMu16L1f0L2f16QL3Filtered24Q hltL3fL1sMu16L1f0L2f16QL3Filtered30Q hltL3fL1sMu16L1f0L2f16QL3Filtered40Q hltL3fL1sMu16erL3Filtered20 hltL3fL1sMu3L3Filtered5 hltL3fL1sMu3L3Filtered8 hltL3fL1sMu7Eta2p1L1f0L2f7QL3Filtered8Q hltL3fL1sMu7L1fEta2p1L2fEta2p1f7L3FilteredEta2p1Filtered15 hltL3fL1sMu7L3Filtered12 hltL3fL1sSingleMu7Eta2p1L1f0L2f7QL3Filtered8Q hltL3reliso1p0mufiltermu20 hltL3reliso1p0mufiltermu5 hltMu14Ele14CaloIdTTrkIdVLMass8Filter hltMu15TkMu5DCAL3Filtered15 hltMu15TkMu5TrackMassFilteredOnia hltMu5TrackJpsiL3Filtered3 hltMu8Ele8CaloIdTTrkIdVLMass8Filter hltOverlapFilterIsoMu17LooseIsoPFTau20 hltOverlapFilterIsoMu8LooseIsoPFTau20 hltOverlapFilterMu17LooseIsoPFTau20 hltOverlapFilterMu8LooseIsoPFTau20 hltOverlapFilterSingleIsoMu8LooseIsoPFTau20 hltSingleMuOpenCandidateL3Filtered12 hltSingleMuOpenCandidateL3Filtered5 hltSingleMuOpenIsoCenJetL3crIsoRhoFiltered0p15 + Paths (72/41): HLT_PFNoPUHT350_Mu15_PFMET45_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET50_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET45_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET50_v5(*,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(L,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(L,3) HLT_Mu15_eta2p1_DiCentral_20_v2(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(L,3) HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET40_v9(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET50_v9(*,3) HLT_Mu22_Photon22_CaloIdL_v8(*,3) HLT_Mu30_Ele30_CaloIdL_v9(*,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(L,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(L,3) HLT_Mu12_eta2p1_DiCentral_20_v9(L,3) HLT_Mu8_DiJet30_v8(L,3) HLT_Mu8_TriJet30_v8(L,3) HLT_IsoMu15_eta2p1_L1ETM20_v8(L,3) HLT_IsoMu15_eta2p1_LooseIsoPFTau35_Trk20_Prong1_L1ETM20_v11(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v8(L,3) HLT_IsoMu20_eta2p1_v8(L,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(*,3) HLT_IsoMu24_eta2p1_v16(L,3) HLT_IsoMu30_eta2p1_v16(L,3) HLT_IsoMu34_eta2p1_v14(L,3) HLT_IsoMu40_eta2p1_v11(L,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_PFMET20_v2(*,3) HLT_IsoMu24_v18(L,3) HLT_IsoMu30_v12(L,3) HLT_IsoMu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(L,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(L,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(L,3) HLT_IsoMu8_eta2p1_LooseIsoPFTau20_v2(L,3) HLT_Mu15_eta2p1_L1ETM20_v6(L,3) HLT_Mu17_v6(L,3) HLT_Mu17_eta2p1_LooseIsoPFTau20_v8(L,3) HLT_Mu24_eta2p1_v6(L,3) HLT_Mu30_eta2p1_v6(L,3) HLT_Mu40_eta2p1_v12(L,3) HLT_Mu50_eta2p1_v9(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_Mu24_v17(L,3) HLT_Mu30_v17(L,3) HLT_Mu40_v15(L,3) HLT_RelIso1p0Mu20_v4(L,3) HLT_Mu5_v21(L,3) HLT_RelIso1p0Mu5_v7(L,3) HLT_Mu8_v19(L,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(L,3) HLT_Mu15_eta2p1_v6(L,3) HLT_Mu12_v19(L,3) DST_Mu5_HT250_v5(L,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_PFNoPUHT350_PFMHT40_v4(*,3) Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (4/0): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (4/0): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (4/0): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional hltSingleJet200Regional + Paths (3/0): HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) HLT_PFJet200_v10(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional + Paths (3/0): HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) HLT_PFJet200_v10(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (2/0): HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJet60L1FastJetCentralBPH hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDoubleBJet120Eta2p4L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet160Eta2p4L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSingleJet30L1FastJet hltTriBJet20CentralL1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (25/5): HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Jet160Eta2p4_Jet120Eta2p4_DiBTagIP3DFastPVLoose_v8(*,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_Jet60Eta1p7_Jet53Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_Jet80Eta1p7_Jet70Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_DoublePhoton40_CaloIdL_Rsq0p035_v7(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJet60L1FastJetCentralBPH hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDoubleBJet120Eta2p4L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSingleJet30L1FastJet hltTriBJet20CentralL1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (25/5): HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Jet160Eta2p4_Jet120Eta2p4_DiBTagIP3DFastPVLoose_v8(*,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_Jet60Eta1p7_Jet53Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_Jet80Eta1p7_Jet70Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_DoublePhoton40_CaloIdL_Rsq0p035_v7(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJet60L1FastJetCentralBPH hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDoubleBJet120Eta2p4L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSingleJet30L1FastJet hltTriBJet20CentralL1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (25/5): HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Jet160Eta2p4_Jet120Eta2p4_DiBTagIP3DFastPVLoose_v8(*,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_Jet60Eta1p7_Jet53Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_Jet80Eta1p7_Jet70Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_DoublePhoton40_CaloIdL_Rsq0p035_v7(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltTriBJet20CentralL1FastJet + Paths (9/0): HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltGetJetsfromBLifetime3D1stTrkL25FilterJet20Hbb::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL3FilterJet20HbbL1FastJet + Paths (2/2): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(L,3) Collection: hltGetJetsfromBLifetime3D1stTrkL25FilterJet20Hbb::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL3FilterJet20HbbL1FastJet + Paths (2/2): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(L,3) Collection: hltGetJetsfromDiBLifetime3D1stTrkL25FilterJet20Hbb::HLT + Type IDs: 86 + Filters: hltDiBLifetime3D1stTrkL3FilterJet20HbbL1FastJet + Paths (2/2): HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(L,3) Collection: hltGetJetsfromDiBLifetime3D1stTrkL25FilterJet20Hbb::HLT + Type IDs: 86 + Filters: hltDiBLifetime3D1stTrkL3FilterJet20HbbL1FastJet + Paths (2/2): HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(L,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (3/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) HLT_IsoMu15_eta2p1_LooseIsoPFTau35_Trk20_Prong1_L1ETM20_v11(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (3/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) HLT_IsoMu15_eta2p1_LooseIsoPFTau35_Trk20_Prong1_L1ETM20_v11(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (3/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) HLT_IsoMu15_eta2p1_LooseIsoPFTau35_Trk20_Prong1_L1ETM20_v11(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (3/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) HLT_IsoMu15_eta2p1_LooseIsoPFTau35_Trk20_Prong1_L1ETM20_v11(*,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter hltL2TauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter hltL2TauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltBLifetimeL25FilterbbPhi1stTrackL1FastJetFastPV + Paths (2/0): HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_Jet160Eta2p4_Jet120Eta2p4_DiBTagIP3DFastPVLoose_v8(*,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltBLifetimeL25FilterbbPhi1BL1FastJetFastPV hltBLifetimeL25FilterbbPhi1stTrackL1FastJetFastPV hltBLifetimeL25FilterbbPhiL1FastJetFastPV hltBLifetimeL3FilterbbPhi1BL1FastJetFastPV hltBLifetimeL3FilterbbPhi1BLooseL1FastJetFastPV hltBLifetimeL3FilterbbPhiL1FastJetFastPV hltBLifetimeL3FilterbbPhiLooseL1FastJetFastPV + Paths (5/5): HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(L,3) HLT_Jet160Eta2p4_Jet120Eta2p4_DiBTagIP3DFastPVLoose_v8(L,3) HLT_Jet60Eta1p7_Jet53Eta1p7_DiBTagIP3DFastPV_v8(L,3) HLT_Jet80Eta1p7_Jet70Eta1p7_DiBTagIP3DFastPV_v8(L,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltBLifetimeL25FilterbbPhi1BL1FastJetFastPV hltBLifetimeL25FilterbbPhi1stTrackL1FastJetFastPV hltBLifetimeL25FilterbbPhiL1FastJetFastPV hltBLifetimeL3FilterbbPhi1BL1FastJetFastPV hltBLifetimeL3FilterbbPhi1BLooseL1FastJetFastPV hltBLifetimeL3FilterbbPhiL1FastJetFastPV hltBLifetimeL3FilterbbPhiLooseL1FastJetFastPV + Paths (5/5): HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(L,3) HLT_Jet160Eta2p4_Jet120Eta2p4_DiBTagIP3DFastPVLoose_v8(L,3) HLT_Jet60Eta1p7_Jet53Eta1p7_DiBTagIP3DFastPV_v8(L,3) HLT_Jet80Eta1p7_Jet70Eta1p7_DiBTagIP3DFastPV_v8(L,3) Collection: hltEle5CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET45::HLT + Type IDs: 90 + Filters: hltEle5CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET45 + Paths (1/1): HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v4(L,3) Collection: hltEle5CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET50::HLT + Type IDs: 90 + Filters: hltEle5CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET50 + Paths (1/1): HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v4(L,3) Collection: hltElectron15CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET45::HLT + Type IDs: 90 + Filters: hltElectron15CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET45 + Paths (1/1): HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v4(L,3) Collection: hltElectron15CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET50::HLT + Type IDs: 90 + Filters: hltElectron15CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET50 + Paths (1/1): HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v4(L,3) Collection: hltElectron40CaloIdTTrkIdTCleanedPFHT300NoPU::HLT + Type IDs: 90 + Filters: hltElectron40CaloIdTTrkIdTCleanedPFHT300NoPU + Paths (1/1): HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v4(L,3) Collection: hltPFHT175NoPU::HLT + Type IDs: 90 + Filters: hltPFHT175NoPU + Paths (2/2): HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(L,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(L,3) Collection: hltPFHT225NoPU::HLT + Type IDs: 90 + Filters: hltPFHT225NoPU + Paths (2/2): HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(L,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(L,3) Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (2/2): HLT_PFNoPUHT350_v5(L,3) HLT_Mu40_PFNoPUHT350_v5(L,3) Collection: hltPFHT350PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT350PFMET45 + Paths (1/1): HLT_PFNoPUHT350_Mu15_PFMET45_v5(L,3) Collection: hltPFHT350PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT350PFMET50 + Paths (1/1): HLT_PFNoPUHT350_Mu15_PFMET50_v5(L,3) Collection: hltPFHT400PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET45 + Paths (1/1): HLT_PFNoPUHT400_Mu5_PFMET45_v5(L,3) Collection: hltPFHT400PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET50 + Paths (1/1): HLT_PFNoPUHT400_Mu5_PFMET50_v5(L,3) Collection: hltPFMETProducer::HLT + Type IDs: 90 + Filters: hltPFMET20Filter hltPFMET40Filter hltPFMET50Filter hltPFMHT0 + Paths (3/3): HLT_IsoMu18_CentralPFJet30_CentralPFJet25_PFMET20_v2(L,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET40_v9(L,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET50_v9(L,3) Collection: hltPFMHT40HT350::HLT + Type IDs: 90 + Filters: hltPFMHT40HT350 + Paths (1/1): HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_PFNoPUHT350_PFMHT40_v4(L,3) Collection: hltHITIPTCorrectorHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL3FilterHB + Paths (1/1): HLT_IsoTrackHB_v15(L,3) Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (1/0): HLT_IsoTrackHB_v15(*,3) Collection: hltL1extraParticles:Isolated:HLT + Type IDs: -83 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1EG8DoubleJet20Central hltL1sL1IsoEG12erETM36 hltL1sL1Mu0EG5 hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1SingleEG12 hltL1sL1SingleEG20ORL1SingleEG22 hltL1sL1SingleEG22 hltL1sL1SingleEG24 hltL1sL1SingleEG30 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1SingleIsoEG18erORIsoEG20erOREG22 hltL1sL1SingleIsoEG18erORL1SingleIsoEG20er + Paths (41/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(*,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET40_v9(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET50_v9(*,3) HLT_Mu30_Ele30_CaloIdL_v9(*,3) HLT_Mu22_Photon22_CaloIdL_v8(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Photon20_CaloIdVL_v5(*,3) HLT_L1SingleEG12_v6(L,3) HLT_Ele17_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v7(*,3) HLT_Ele22_CaloIdL_CaloIsoVL_v7(*,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Photon30_v2(*,3) HLT_Photon30_CaloIdVL_v15(*,3) HLT_Ele27_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(*,3) HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(*,3) HLT_Photon36_Photon22_v7(*,3) HLT_Ele30_CaloIdVT_TrkIdT_v7(*,3) HLT_DoubleEle33_CaloIdL_v15(*,3) HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v8(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet150_PFNoPUJet25_v9(*,3) HLT_DoublePhoton40_CaloIdL_Rsq0p035_v7(*,3) HLT_L1SingleEG5_v6(L,3) HLT_Ele8_CaloIdT_TrkIdVL_v6(*,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(*,3) HLT_Ele8_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele8_CaloIdT_TrkIdVL_EG7_v3(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Ele22_eta2p1_WP90NoIso_LooseIsoPFTau20_v8(*,3) Collection: hltL1extraParticles::HLT + Type IDs: -81 + Filters: hltL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL1MuFiltered0Eta2p1 hltL1MuOpenL1Filtered0 hltL1sAlCaEcalPi0Eta hltL1sAlCaRPC hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1Mu0EG5 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu4HTT125 hltL1sL1Mu7erETM26 hltL1sL1Mu8DoubleJetC20 hltL1sL1SingleMu12 hltL1sL1SingleMu12erORSingleMu14er hltL1sL1SingleMu16er hltL1sL1SingleMu3 hltL1sL1SingleMu7 hltL1sL1SingleMuOpen hltL1sL1SingleMuOpenCandidate hltL1sMu12Eta2p1ETM20 hltL1sMu14Eta2p1 hltL1sMu14erORMu16er hltL1sMu16 hltL1sMu16Eta2p1 hltMu5TrackJpsiL1Filtered0 hltRPCMuonNoTriggersL1Filtered0 hltRPCMuonNormaL1Filtered0 + Paths (74/8): HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_L1SingleMuOpen_v7(L,3) HLT_L1SingleMuOpen_AntiBPTX_v7(L,3) AlCa_RPCMuonNoTriggers_v9(L,3) AlCa_RPCMuonNoHits_v9(L,3) AlCa_RPCMuonNormalisation_v9(L,3) HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET40_v9(*,3) HLT_Mu14_Ele14_CaloIdT_TrkIdVL_Mass8_PFMET50_v9(*,3) HLT_Mu30_Ele30_CaloIdL_v9(*,3) HLT_Mu22_Photon22_CaloIdL_v8(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_IsoMu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_L1SingleMu12_v2(L,3) HLT_Mu17_v6(*,3) HLT_RelIso1p0Mu20_v4(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_RelIso1p0Mu5_v7(*,3) HLT_Mu12_v19(*,3) HLT_Mu15_eta2p1_v6(*,3) HLT_IsoMu8_eta2p1_LooseIsoPFTau20_v2(*,3) HLT_IsoMu15_eta2p1_L1ETM20_v8(*,3) HLT_IsoMu15_eta2p1_LooseIsoPFTau35_Trk20_Prong1_L1ETM20_v11(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(*,3) HLT_Mu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v8(*,3) HLT_Mu17_eta2p1_LooseIsoPFTau20_v8(*,3) HLT_Mu24_v17(*,3) HLT_Mu30_v17(*,3) HLT_Mu40_v15(*,3) HLT_IsoMu24_v18(*,3) HLT_IsoMu30_v12(*,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_PFMET20_v2(*,3) HLT_L2Mu20_eta2p1_NoVertex_v2(*,3) HLT_Mu24_eta2p1_v6(*,3) HLT_Mu30_eta2p1_v6(*,3) HLT_Mu40_eta2p1_v12(*,3) HLT_Mu50_eta2p1_v9(*,3) HLT_IsoMu20_eta2p1_v8(*,3) HLT_IsoMu24_eta2p1_v16(*,3) HLT_IsoMu30_eta2p1_v16(*,3) HLT_IsoMu34_eta2p1_v14(*,3) HLT_IsoMu40_eta2p1_v11(*,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJetC522828 + Paths (51/12): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_Jet60Eta1p7_Jet53Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_Jet80Eta1p7_Jet70Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_HT200_v6(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Jet160Eta2p4_Jet120Eta2p4_DiBTagIP3DFastPVLoose_v8(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_PFJet200_v10(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJetC522828 + Paths (50/12): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_Jet60Eta1p7_Jet53Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_Jet80Eta1p7_Jet70Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_HT200_v6(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_PFJet200_v10(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJetC522828 + Paths (50/12): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_Jet60Eta1p7_Jet53Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_Jet80Eta1p7_Jet70Eta1p7_DiBTagIP3DFastPV_v8(*,3) HLT_HT200_v6(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_RsqMR40_Rsq0p04_MR200_v5(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_DiBTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_PFJet200_v10(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -87 + Filters: hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1ETM30 hltL1sL1ETM36ORETM40 hltL1sL1ETM36ORETM40ORETM50 hltL1sL1ETM36or40 hltL1sL1ETM40 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1IsoEG12erETM36 hltL1sL1Mu7erETM26 hltL1sMu12Eta2p1ETM20 + Paths (8/2): HLT_L1ETM30_v2(L,3) HLT_L1ETM40_v2(L,3) HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(*,3) HLT_IsoMu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_IsoMu15_eta2p1_L1ETM20_v8(*,3) HLT_IsoMu15_eta2p1_LooseIsoPFTau35_Trk20_Prong1_L1ETM20_v11(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (0/0): Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu4HTT125 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (26/8): HLT_PFNoPUHT350_v5(*,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_PFNoPUHT350_PFMHT40_v4(*,3) HLT_PFNoPUHT350_Mu15_PFMET45_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET50_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET45_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET50_v5(*,3) HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v4(*,3) HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v4(*,3) HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v4(*,3) HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v4(*,3) HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v4(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_HT500_v7(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT450_v7(L,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_RelIso1p0Mu5_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve140 hltDiPFJetAve40 hltDiPFJetAve80 hltIsoMu18eta2p4CentralPFJet30MuCleaned hltIsoMu18eta2p4DiCentralPFJet25MuCleaned hltIsoMu20eta2p1CentralPFJet80MuCleaned hltMu18eta2p4CentralPFJet30MuCleaned hltMu18eta2p4DiCentralPFJet25MuCleaned + Paths (7/6): HLT_DiPFJetAve140_v11(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(L,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_PFMET20_v2(*,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve140 hltDiPFJetAve40 hltDiPFJetAve80 hltIsoMu18eta2p4CentralPFJet30MuCleaned hltIsoMu18eta2p4DiCentralPFJet25MuCleaned hltIsoMu20eta2p1CentralPFJet80MuCleaned hltMu18eta2p4CentralPFJet30MuCleaned hltMu18eta2p4DiCentralPFJet25MuCleaned + Paths (7/6): HLT_DiPFJetAve140_v11(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(L,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_PFMET20_v2(*,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltIsoMu18eta2p4CentralPFJet30MuCleaned hltIsoMu18eta2p4DiCentralPFJet25MuCleaned hltIsoMu20eta2p1CentralPFJet80MuCleaned hltMu18eta2p4CentralPFJet30MuCleaned hltMu18eta2p4DiCentralPFJet25MuCleaned + Paths (4/3): HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(L,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_PFMET20_v2(*,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(L,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 0 86 + Filters: hltDiPFNoPUJet25 hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet45EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet50EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet30EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet35EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet40EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet25EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet30EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet100EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet150EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet25EleCleaned hltIsoMu172p1CentralBPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet45MuCleaned hltIsoMu172p1DiCentralPFNoPUJet30MuCleaned hltIsoMu172p1DiCentralPFNoPUJet35MuCleaned hltIsoMu172p1TriCentralPFNoPUJet25MuCleaned hltIsoMu172p1TriCentralPFNoPUJet30MuCleaned hltMu172p1CentralBPFNoPUJet30MuCleaned hltMu172p1CentralPFNoPUJet45MuCleaned hltMu172p1DiCentralPFNoPUJet35MuCleaned hltMu172p1TriCentralPFNoPUJet25MuCleaned + Paths (13/11): HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(L,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet150_PFNoPUJet25_v9(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(L,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(L,3) HLT_Mu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 0 86 + Filters: hltDiPFNoPUJet25 hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet45EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet50EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet30EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet35EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet40EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet25EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet30EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet100EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet25EleCleaned hltIsoMu172p1CentralBPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet45MuCleaned hltIsoMu172p1DiCentralPFNoPUJet30MuCleaned hltIsoMu172p1DiCentralPFNoPUJet35MuCleaned hltIsoMu172p1TriCentralPFNoPUJet25MuCleaned hltIsoMu172p1TriCentralPFNoPUJet30MuCleaned hltMu172p1CentralBPFNoPUJet30MuCleaned hltMu172p1CentralPFNoPUJet45MuCleaned hltMu172p1DiCentralPFNoPUJet35MuCleaned hltMu172p1TriCentralPFNoPUJet25MuCleaned + Paths (13/10): HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(L,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet150_PFNoPUJet25_v9(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(L,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(L,3) HLT_Mu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 0 86 + Filters: hltDiPFNoPUJet25 hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet45EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet50EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet30EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet35EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet40EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet25EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet30EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet100EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet25EleCleaned hltIsoMu172p1CentralBPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet45MuCleaned hltIsoMu172p1DiCentralPFNoPUJet30MuCleaned hltIsoMu172p1DiCentralPFNoPUJet35MuCleaned hltIsoMu172p1TriCentralPFNoPUJet25MuCleaned hltIsoMu172p1TriCentralPFNoPUJet30MuCleaned hltMu172p1CentralBPFNoPUJet30MuCleaned hltMu172p1CentralPFNoPUJet45MuCleaned hltMu172p1DiCentralPFNoPUJet35MuCleaned hltMu172p1TriCentralPFNoPUJet25MuCleaned + Paths (13/10): HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(L,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet150_PFNoPUJet25_v9(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(L,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(L,3) HLT_Mu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(*,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 0 + Filters: hltDiPFNoPUJet25 hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet45EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet50EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet30EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet35EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet40EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet25EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet30EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet25EleCleaned + Paths (6/4): HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet150_PFNoPUJet25_v9(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(L,3) Collection: hltMu17BLifetimeL25PFNoPUJetsSingleTop::HLT + Type IDs: 86 + Filters: hltMu17BLifetimeL3PFNoPUFilterSingleTop + Paths (1/1): HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(L,3) Collection: hltMu17BLifetimeL25PFNoPUJetsSingleTop::HLT + Type IDs: 86 + Filters: hltMu17BLifetimeL3PFNoPUFilterSingleTop + Paths (1/1): HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(L,3) Collection: hltMu17BLifetimeL25PFNoPUJetsSingleTopNoIso::HLT + Type IDs: 86 + Filters: hltMu17BLifetimeL3PFNoPUFilterSingleTopNoIso + Paths (1/1): HLT_Mu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(L,3) Collection: hltMu17BLifetimeL25PFNoPUJetsSingleTopNoIso::HLT + Type IDs: 86 + Filters: hltMu17BLifetimeL3PFNoPUFilterSingleTopNoIso + Paths (1/1): HLT_Mu17_eta2p1_CentralPFNoPUJet30_BTagIPIter_v5(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) indx x y z rho chi2 ndf + 0 0.24 0.39 0.39 0.46 1.3e+02 1.5e+02 + 1 0.25 0.39 0.39 0.46 25 32 + 2 0.24 0.39 0.39 0.46 32 31 + 3 0.24 0.39 0.39 0.46 47 58 + 4 0.24 0.38 0.38 0.45 2 6.8 + 5 0.24 0.39 0.39 0.45 18 28 + 6 0.25 0.4 0.4 0.47 8.5 12 + 7 0.27 0.36 0.36 0.45 3.8 6.7 + 8 0.27 0.38 0.38 0.47 3.6 4.7 + 9 0.24 0.4 0.4 0.47 1.9 6.8 + 10 0.23 0.38 0.38 0.44 5.7 4.6 + 11 0.22 0.41 0.41 0.46 11 9.8 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002009 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 4th record. Run 1, Event 7002010, LumiSection 70021 at 19-Sep-2014 22:10:04.638 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002010 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002010 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltL1SeededRecoEcalCandidate::HLT + Type IDs: 81 92 + Filters: hltEle13WP90ClusterShapeFilter hltEle13WP90NoIsoHEFilter hltEle13WP90NoIsoPixelMatchFilter hltSingleEle13WP90RhoClusterShapeFilter + Paths (1/0): HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(*,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltPixelMatchElectronsActivity::HLT + Type IDs: 82 + Filters: hltMu8Ele8CaloIdTTrkIdVLMass8Filter hltSingleElectronEt8CaloIdTTrkIdVLNoCandDphiFilter + Paths (2/0): HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) Collection: hltPixelMatchElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle13WP90NoIsoDetaFilter hltEle13WP90NoIsoOneOEMinusOneOPFilter + Paths (1/0): HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(*,3) Collection: hltPixelMatchElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle13WP90NoIsoDetaFilter hltEle13WP90NoIsoDphiFilter hltEle13WP90NoIsoOneOEMinusOneOPFilter hltEle8CaloIdTTrkIdTL1EG8DoubleJet20CentralDphiFilter hltEle8CaloIdTTrkIdVLDphiFilter hltEle8CaloIdTTrkIdVLDphiFilterL1Mu5DoubleEG5 hltEle8CaloIdTTrkIdVLEG7DphiFilter hltOverlapFilterEle13WP90LooseIsoPFTau20 + Paths (7/3): HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdVL_v6(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(*,3) HLT_Ele8_CaloIdT_TrkIdVL_EG7_v3(L,3) Collection: hltL2MuonCandidates::HLT + Type IDs: 83 + Filters: hltL1HTT150singleMuL2PreFiltered0 hltL1Mu0EG5L2MuFiltered0 hltL1Mu0HTT100L2Filtered0 hltL1Mu0HTT100ORMu4HTT125L2Filtered0 hltL1Mu12EG7ORL1MuOpenEG12L2MuFiltered0 hltL1Mu4HTT125L2Filtered0 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L2Filtered5 hltL2Mu5DoubleEG5L2Filtered5 hltL2fL1sMu3L2Filtered3 hltL2fL1sMu7Eta2p1L1f0L2Filtered7Q hltL2fL1sMu7L1fEta2p1L2FilteredEta2p1Filtered7 hltL2fL1sMu7L2Filtered7 hltL2fL1sSingleMu7Eta2p1L1f0L2Filtered7Q hltMu5TrackJpsiL2Filtered3 hltSingleMuOpenCandidateL2Filtered0 hltSingleMuOpenCandidateL2Filtered3 + Paths (6/0): HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) DST_Mu5_HT250_v5(*,3) Collection: hltL3MuonCandidates::HLT + Type IDs: 83 + Filters: hltL1HTT150singleMuL3PreFiltered5 hltL1Mu0EG5L3MuFiltered7 hltL1Mu0HTT100L3Filtered5 hltL1Mu0HTT100ORMu4HTT125L3Filtered8 hltL1Mu4HTT125L3Filtered5 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L3Filtered8 hltL3Mu8DoubleJetC20L3Filtered8 hltL3fL1sMu3L3Filtered5 hltL3fL1sMu3L3Filtered8 hltL3fL1sMu7Eta2p1L1f0L2f7QL3Filtered8Q hltL3fL1sSingleMu7Eta2p1L1f0L2f7QL3Filtered8Q hltMu5DoubleEG5L3Filtered8 hltMu5Track1JpsiPixelMassFiltered hltMu5TrackJpsiL3Filtered3 hltMu8Ele8CaloIdTTrkIdVLMass8Filter hltOverlapFilterMu8LooseIsoPFTau20 hltSingleMuOpenCandidateL3Filtered5 + Paths (9/7): HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu8_DiJet30_v8(L,3) HLT_Mu8_TriJet30_v8(L,3) HLT_Mu8_QuadJet30_v8(L,3) HLT_Mu5_v21(L,3) HLT_Mu8_v19(L,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(L,3) DST_Mu5_HT250_v5(L,3) Collection: hltMuTrackJpsiPixelTrackCands::HLT + Type IDs: 91 + Filters: hltMu5Track1JpsiPixelMassFiltered + Paths (0/0): Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSingleJet30L1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (7/7): HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_RsqMR45_Rsq0p09_v5(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadJet45_v1(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltSingleBJet60Eta1p7L1FastJet hltSingleJet30L1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (7/7): HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_RsqMR45_Rsq0p09_v5(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadJet45_v1(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltCentralJet50 hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltSingleBJet60Eta1p7L1FastJet hltSingleJet30L1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (5/5): HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadJet45_v1(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltSingleJet30L1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (5/5): HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadJet45_v1(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltSingleJet30L1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (5/5): HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadJet45_v1(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltQuadJet25HbbZbb hltQuadJet30Central hltSingleJet30L1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (4/4): HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltQuadJet25HbbZbb + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCentralJet15 hltL1FastJetQuad18HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCentralJet15 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (0/0): Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL3FilterHbbCSV + Paths (0/0): Collection: hltPFHT175NoPU::HLT + Type IDs: 90 + Filters: hltPFHT175NoPU + Paths (1/1): HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(L,3) Collection: hltPFHT225NoPU::HLT + Type IDs: 90 + Filters: hltPFHT225NoPU + Paths (1/1): HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(L,3) Collection: hltPFHT350MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT350MET100orMHT150 + Paths (0/0): Collection: hltPFHT350MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT350MET100orMHT150 + Paths (0/0): Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (1/1): HLT_PFNoPUHT350_v5(L,3) Collection: hltPFHT400PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET45 + Paths (0/0): Collection: hltPFHT400PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET50 + Paths (0/0): Collection: hltPFMETnoMu105::HLT + Type IDs: 90 + Filters: hltPFMETnoMu105 + Paths (0/0): Collection: hltMet::HLT + Type IDs: 87 + Filters: hltMET50 hltMET65 + Paths (0/0): Collection: hltMetClean::HLT + Type IDs: 87 + Filters: hltMETClean25 + Paths (0/0): Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (0/0): Collection: hltL1extraParticles:Isolated:HLT + Type IDs: -83 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG5 hltL1sL1EG8DoubleJet20Central hltL1sL1IsoEG12erETM36 hltL1sL1Mu0EG5 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1SingleEG12 hltL1sL1SingleEG5 hltL1sL1SingleEG7 + Paths (11/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(*,3) HLT_L1SingleEG12_v6(L,3) HLT_L1SingleEG5_v6(L,3) HLT_Ele8_CaloIdT_TrkIdVL_v6(*,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(*,3) HLT_Ele8_CaloIdT_TrkIdVL_EG7_v3(*,3) Collection: hltL1extraParticles::HLT + Type IDs: -81 + Filters: hltL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL1MuFiltered0Eta2p1 hltL1MuOpenL1Filtered0 hltL1sAlCaEcalPi0Eta hltL1sAlCaRPC hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1Mu0EG5 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu4HTT125 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1Mu7erETM26 hltL1sL1Mu8DoubleJetC20 hltL1sL1SingleMu3 hltL1sL1SingleMu7 hltL1sL1SingleMuOpen hltL1sL1SingleMuOpenCandidate hltMu5TrackJpsiL1Filtered0 hltRPCMuonNormaL1Filtered0 + Paths (13/5): HLT_L1SingleMuOpen_v7(L,3) HLT_L1SingleMuOpen_AntiBPTX_v7(L,3) AlCa_RPCMuonNormalisation_v9(L,3) HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (23/9): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_RsqMR45_Rsq0p09_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_QuadJet45_v1(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (23/9): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_RsqMR45_Rsq0p09_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_QuadJet45_v1(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (23/9): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_RsqMR45_Rsq0p09_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_QuadJet45_v1(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (18/6): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_QuadJet45_v1(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1SingleForJet16 hltL1sL1SingleJet16 hltL1sL1SingleJet36 + Paths (7/3): HLT_HcalNZS_v10(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1SingleForJet16 hltL1sL1SingleJet16 + Paths (4/2): HLT_HcalNZS_v10(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -87 + Filters: hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1ETM30 hltL1sL1ETM36ORETM40 hltL1sL1ETM36ORETM40ORETM50 hltL1sL1ETM36or40 hltL1sL1ETM40 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1IsoEG12erETM36 hltL1sL1Mu7erETM26 + Paths (4/2): HLT_L1ETM30_v2(L,3) HLT_L1ETM40_v2(L,3) HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (0/0): Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu4HTT125 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (9/4): HLT_PFNoPUHT350_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_QuadJet45_v1(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltCentralPFJet80 hltDiCentralPFJet25 hltDiPFJetAve40 hltDiPFJetAve80 hltPFNHEF95Filter + Paths (2/2): HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltDiCentralPFJet25 hltDiPFJetAve40 hltDiPFJetAve80 + Paths (2/2): HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltDiCentralPFJet25 + Paths (0/0): Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltDiCentralPFJet25 + Paths (0/0): Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet25 + Paths (0/0): Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltSelectedEle13PFTausTrackFindingLooseIsolation::HLT + Type IDs: 84 + Filters: hltEle13PFTau20TrackLooseIso hltOverlapFilterEle13WP90LooseIsoPFTau20 + Paths (1/1): HLT_Ele13_eta2p1_WP90NoIso_LooseIsoPFTau20_L1ETM36_v2(L,3) Collection: hltSelectedMu8PFTausTrackFindingLooseIsolation::HLT + Type IDs: 84 + Filters: hltMu8PFTau20TrackLooseIso hltOverlapFilterMu8LooseIsoPFTau20 + Paths (1/1): HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(L,3) Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (0/0): Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (0/0): indx x y z rho chi2 ndf + 0 0.24 0.39 0.39 0.46 1e+02 1.4e+02 + 1 0.25 0.39 0.39 0.46 1.3e+02 1.6e+02 + 2 0.24 0.39 0.39 0.46 74 92 + 3 0.25 0.39 0.39 0.46 77 67 + 4 0.24 0.39 0.39 0.46 66 80 + 5 0.25 0.4 0.4 0.47 24 49 + 6 0.25 0.4 0.4 0.47 29 54 + 7 0.24 0.39 0.39 0.46 30 35 + 8 0.24 0.4 0.4 0.47 33 28 + 9 0.25 0.39 0.39 0.46 13 18 + 10 0.25 0.39 0.39 0.47 35 36 + 11 0.24 0.38 0.38 0.45 21 21 + 12 0.24 0.39 0.39 0.46 22 28 + 13 0.24 0.39 0.39 0.45 4.1 8.9 + 14 0.24 0.39 0.39 0.46 13 21 + 15 0.25 0.39 0.39 0.46 7.4 4.6 + 16 0.25 0.39 0.39 0.46 7.3 6.6 + 17 0.25 0.39 0.39 0.47 6.4 11 + 18 0.25 0.38 0.38 0.46 6.7 15 + 19 0.25 0.4 0.4 0.47 3.1 6.8 + 20 0.24 0.42 0.42 0.49 13 8.1 + 21 0.25 0.38 0.38 0.45 9.8 11 + 22 0.24 0.38 0.38 0.45 2.4 4.8 + 23 0.24 0.39 0.39 0.46 3.3 8.7 + 24 0.22 0.41 0.41 0.47 3.3 4.9 + 25 0.23 0.38 0.38 0.44 5.3 3.6 + 26 0.28 0.37 0.37 0.47 4.9 3.2 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002010 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 5th record. Run 1, Event 7002012, LumiSection 70021 at 19-Sep-2014 22:10:04.647 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002012 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002012 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltL1SeededRecoEcalCandidate::HLT + Type IDs: 81 92 + Filters: hltEG20CaloIdVLHEFilter hltEle13WP90ClusterShapeFilter hltEle13WP90NoIsoHEFilter hltEle13WP90NoIsoPixelMatchFilter hltEle13WP90RhoEcalIsoFilter hltEle13WP90RhoHEFilter hltEle13WP90RhoHcalIsoFilter hltEle13WP90RhoPixelMatchFilter hltEle17CaloIdLCaloIsoVLPixelMatchFilter hltEle22CaloIdLCaloIsoVLPixelMatchFilter hltEle22WP90NoIsoHEFilter hltEle22WP90NoIsoPixelMatchFilter hltEle22WP90RhoClusterShapeFilter hltEle22WP90RhoEcalIsoFilter hltEle22WP90RhoHEFilter hltEle22WP90RhoHcalIsoFilter hltEle22WP90RhoPixelMatchFilter hltEle8CaloIdLCaloIsoVLPixelMatchFilter hltSingleEle13WP90RhoClusterShapeFilter hltSingleEle13WP90RhoEcalIsoFilter hltSingleEle13WP90RhoHEFilter hltSingleEle13WP90RhoHcalIsoFilter hltSingleEle13WP90RhoPixelMatchFilter + Paths (4/4): HLT_Photon20_CaloIdVL_v5(L,3) HLT_Ele17_CaloIdL_CaloIsoVL_v18(L,3) HLT_Ele22_CaloIdL_CaloIsoVL_v7(L,3) HLT_Ele8_CaloIdL_CaloIsoVL_v18(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidateSC5::HLT + Type IDs: 92 + Filters: hltEle5SC5JpsiPMMassFilter + Paths (1/1): HLT_Ele5_SC5_Jpsi_Mass2to15_v6(L,3) Collection: hltPixelMatch3HitElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoFilter hltEle5SC5JpsiTrackIsolFilter hltEle8TightIdLooseIsoTrackIsoFilter + Paths (5/2): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v7(L,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Ele5_SC5_Jpsi_Mass2to15_v6(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(L,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (1/0): HLT_PFJet80_v10(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (1/0): HLT_PFJet80_v10(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (1/0): HLT_PFJet80_v10(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (1/0): HLT_PFJet80_v10(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (1/0): HLT_PFJet80_v10(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (1/0): HLT_PFJet80_v10(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet + Paths (9/6): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_RsqMR45_Rsq0p09_v5(L,3) HLT_RsqMR55_Rsq0p09_MR150_v6(L,3) HLT_RsqMR60_Rsq0p09_MR150_v6(L,3) HLT_RsqMR65_Rsq0p09_MR150_v5(L,3) HLT_SixJet35_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleCentralJet65L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltSingleBJet60Eta1p7L1FastJet + Paths (9/6): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_RsqMR45_Rsq0p09_v5(L,3) HLT_RsqMR55_Rsq0p09_MR150_v6(L,3) HLT_RsqMR60_Rsq0p09_MR150_v6(L,3) HLT_RsqMR65_Rsq0p09_MR150_v5(L,3) HLT_SixJet35_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadJet25HbbZbb + Paths (4/1): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_SixJet35_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadJet25HbbZbb + Paths (4/1): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_SixJet35_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadJet25HbbZbb + Paths (4/1): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_SixJet35_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltQuadJet25HbbZbb + Paths (4/1): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_SixJet35_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF + Paths (3/0): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF + Paths (3/0): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF + Paths (3/0): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltFilterL2EtCutSingleIsoPFTau35Trk20 + Paths (0/0): Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL3FilterHbbCSV + Paths (1/0): HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) Collection: hltPFMET80MuORNoMu::HLT + Type IDs: 90 + Filters: hltPFMET80MuORNoMu + Paths (1/1): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(L,3) Collection: hltPFMET80MuORNoMu::HLT + Type IDs: 90 + Filters: hltPFMET80MuORNoMu + Paths (1/1): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(L,3) Collection: hltPFMETProducer::HLT + Type IDs: 90 + Filters: hltPFMET80Filter + Paths (2/2): HLT_DiCentralPFJet30_PFMET80_v7(L,3) HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(L,3) Collection: hltPFMETnoMu105::HLT + Type IDs: 90 + Filters: hltPFMETnoMu105 + Paths (0/0): Collection: hltMet::HLT + Type IDs: 87 + Filters: hltMET50 hltMET65 hltMET70 hltMET75 hltMET80 + Paths (5/2): HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_MET80_v5(L,3) HLT_MET80_Parked_v5(L,3) Collection: hltMetClean::HLT + Type IDs: 87 + Filters: hltMETClean25 + Paths (0/0): Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (0/0): Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (0/0): Collection: hltIsolPixelTrackProdHE::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHE + Paths (0/0): Collection: hltL1extraParticles:Isolated:HLT + Type IDs: -83 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1IsoEG12erETM36 hltL1sL1SingleEG12 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1SingleIsoEG18erORIsoEG20erOREG22 hltL1sL1SingleIsoEG18erORL1SingleIsoEG20er hltL1sL1TripleEG7 + Paths (13/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Ele5_SC5_Jpsi_Mass2to15_v6(*,3) HLT_Photon20_CaloIdVL_v5(*,3) HLT_L1SingleEG12_v6(L,3) HLT_Ele17_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v7(*,3) HLT_Ele22_CaloIdL_CaloIsoVL_v7(*,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_L1SingleEG5_v6(L,3) HLT_Ele8_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1TripleEG7 + Paths (7/3): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Ele5_SC5_Jpsi_Mass2to15_v6(*,3) HLT_L1SingleEG5_v6(L,3) HLT_Ele8_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (17/8): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_RsqMR45_Rsq0p09_v5(*,3) HLT_RsqMR55_Rsq0p09_MR150_v6(*,3) HLT_RsqMR60_Rsq0p09_MR150_v6(*,3) HLT_RsqMR65_Rsq0p09_MR150_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (17/8): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_RsqMR45_Rsq0p09_v5(*,3) HLT_RsqMR55_Rsq0p09_MR150_v6(*,3) HLT_RsqMR60_Rsq0p09_MR150_v6(*,3) HLT_RsqMR65_Rsq0p09_MR150_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (10/6): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1SingleForJet16 hltL1sL1SingleJet16 hltL1sL1SingleJet36 + Paths (7/4): HLT_HcalNZS_v10(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1SingleForJet16 hltL1sL1SingleJet16 + Paths (5/3): HLT_HcalNZS_v10(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1SingleForJet16 hltL1sL1SingleJet16 + Paths (5/3): HLT_HcalNZS_v10(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (10/6): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (6/4): HLT_HcalNZS_v10(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sHcalNZS hltL1sL1SingleJet16 + Paths (4/2): HLT_HcalNZS_v10(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -87 + Filters: hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1ETM30 hltL1sL1ETM36ORETM40 hltL1sL1ETM36ORETM40ORETM50 hltL1sL1ETM36or40 hltL1sL1ETM40 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1IsoEG12erETM36 + Paths (7/2): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_L1ETM30_v2(L,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFJet30_PFMET80_BTagCSV07_v6(*,3) HLT_MET80_v5(*,3) HLT_MET80_Parked_v5(*,3) HLT_L1ETM40_v2(L,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (0/0): Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sAlCaEcalPi0Eta hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (4/3): DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_SixJet35_v6(*,3) HLT_HT250_v7(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltCentralPFJet80 hltDiCentralPFJet25 hltDiPFJetAve40 hltPFNHEF95Filter + Paths (1/1): HLT_DiPFJetAve40_v10(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltDiCentralPFJet25 hltDiPFJetAve40 + Paths (1/1): HLT_DiPFJetAve40_v10(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet25 + Paths (0/0): Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet25 + Paths (0/0): Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet25 + Paths (0/0): Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet25 + Paths (0/0): Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): indx x y z rho chi2 ndf + 0 0.25 0.39 0.39 0.46 67 99 + 1 0.24 0.39 0.39 0.46 42 52 + 2 0.24 0.4 0.4 0.47 45 63 + 3 0.24 0.39 0.39 0.46 25 32 + 4 0.24 0.39 0.39 0.46 30 38 + 5 0.25 0.4 0.4 0.47 34 36 + 6 0.25 0.39 0.39 0.46 33 38 + 7 0.24 0.39 0.39 0.46 6.7 15 + 8 0.24 0.4 0.4 0.46 12 18 + 9 0.25 0.39 0.39 0.47 22 29 + 10 0.24 0.39 0.39 0.46 14 16 + 11 0.24 0.39 0.39 0.46 22 21 + 12 0.24 0.4 0.4 0.46 15 24 + 13 0.22 0.41 0.41 0.47 15 18 + 14 0.25 0.39 0.39 0.46 11 16 + 15 0.24 0.39 0.39 0.45 5.4 6.5 + 16 0.24 0.4 0.4 0.47 12 14 + 17 0.24 0.39 0.39 0.46 8.6 10 + 18 0.25 0.39 0.39 0.47 7.3 8.6 + 19 0.24 0.39 0.39 0.46 13 15 + 20 0.24 0.41 0.41 0.48 5 6.6 + 21 0.25 0.39 0.39 0.46 13 7.6 + 22 0.19 0.37 0.37 0.42 1 4.9 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002012 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 6th record. Run 1, Event 7002024, LumiSection 70021 at 19-Sep-2014 22:10:04.662 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002024 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002024 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltL2MuonCandidates::HLT + Type IDs: 83 + Filters: hltDimuon0or33L2PreFiltered0 hltDimuon30L2PreFiltered0 hltDimuon33L2PreFiltered0 hltDimuonL2PreFiltered0 hltDoubleMu4L2PreFiltered hltIgnoredL1SingleMuOpenL2DiMuFiltered0 hltL1DoubleMu10MuOpenORDoubleMu103p5L2DiMuFiltered0 hltL1HTT150singleMuL2PreFiltered0 hltL1HTT150singleMuL2PreFiltered10 hltL1Mu0HTT100L2Filtered0 hltL1Mu0HTT100ORL1Mu4HTT125L2QualMuFiltered16 hltL1Mu0HTT100ORMu4HTT125L2Filtered0 hltL1Mu4HTT125L2Filtered0 hltL2L1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL2MuFiltered10Eta2p1 hltL2fL1DoubleMu10MuOpenOR3p5L1f0L2Filtered10 hltL2fL1sDoubleMu10MuOpenOR3p5L1f0L2Filtered10 hltL2fL1sMu12Eta2p1L1f0L2Filtered12Q hltL2fL1sMu12L2Filtered12 hltL2fL1sMu14Eta2p1L1f0L2Filtered14Q hltL2fL1sMu14erORMu16erL1f0L2Filtered14Q hltL2fL1sMu16Eta2p1L1f0L2Filtered16Q hltL2fL1sMu16Eta2p4L1f0L2Filtered16Q hltL2fL1sMu16L1f0L2Filtered16Q hltL2fL1sMu16erL2Filtered16 hltL2fL1sMu3L2Filtered3 hltL2fL1sMu70Eta2p1L1f0L2Filtered70QCha2 hltL2fL1sMu7Eta2p1L1f0L2Filtered7Q hltL2fL1sMu7L1fEta2p1L2FilteredEta2p1Filtered7 hltL2fL1sMu7L2Filtered7 hltL2fL1sSingleMu7Eta2p1L1f0L2Filtered7Q hltL2pfL1DoubleMu10MuOpenOR3p5L1f0L2PreFiltered0 hltMu15TkMu5DCAL2Filtered10 hltMu5L2Mu3L2PreFiltered0 hltMu5TrackJpsiL2Filtered3 hltSingleMuOpenCandidateL2Filtered0 hltSingleMuOpenCandidateL2Filtered3 + Paths (45/0): HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_Mu60_PFNoPUHT350_v5(*,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_IsoMu15_eta2p1_L1ETM20_v8(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) HLT_Mu17_v6(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(*,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_Mu24_eta2p1_v6(*,3) HLT_Mu30_eta2p1_v6(*,3) HLT_Mu40_eta2p1_v12(*,3) HLT_Mu50_eta2p1_v9(*,3) HLT_IsoMu20_eta2p1_v8(*,3) HLT_IsoMu24_eta2p1_v16(*,3) HLT_IsoMu30_eta2p1_v16(*,3) HLT_IsoMu34_eta2p1_v14(*,3) HLT_IsoMu40_eta2p1_v11(*,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(*,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_Mu24_v17(*,3) HLT_Mu30_v17(*,3) HLT_Mu40_v15(*,3) HLT_IsoMu24_v18(*,3) HLT_IsoMu30_v12(*,3) HLT_IsoMu20_WCandPt80_v5(*,3) HLT_RelIso1p0Mu20_v4(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_RelIso1p0Mu5_v7(*,3) HLT_Mu15_eta2p1_v6(*,3) HLT_Mu12_v19(*,3) DST_Mu5_HT250_v5(*,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) Collection: hltL2MuonCandidates::HLT + Type IDs: 83 + Filters: hltDimuon0or33L2PreFiltered0 hltDimuon30L2PreFiltered0 hltDimuon33L2PreFiltered0 hltDimuonL2PreFiltered0 hltDoubleMu4L2PreFiltered hltIgnoredL1SingleMuOpenL2DiMuFiltered0 hltL1DoubleMu10MuOpenORDoubleMu103p5L2DiMuFiltered0 hltL1HTT150singleMuL2PreFiltered0 hltL1HTT150singleMuL2PreFiltered10 hltL1Mu0HTT100L2Filtered0 hltL1Mu0HTT100ORL1Mu4HTT125L2QualMuFiltered16 hltL1Mu0HTT100ORMu4HTT125L2Filtered0 hltL2fL1DoubleMu10MuOpenOR3p5L1f0L2Filtered10 hltL2fL1sDoubleMu10MuOpenOR3p5L1f0L2Filtered10 hltL2fL1sMu3L2Filtered3 hltL2pfL1DoubleMu10MuOpenOR3p5L1f0L2PreFiltered0 hltMu5L2Mu3L2PreFiltered0 hltMu5TrackJpsiL2Filtered3 hltSingleMuOpenCandidateL2Filtered0 hltSingleMuOpenCandidateL2Filtered3 + Paths (9/0): HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_Mu60_PFNoPUHT350_v5(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_RelIso1p0Mu5_v7(*,3) DST_Mu5_HT250_v5(*,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) Collection: hltL2MuonCandidatesNoVtx::HLT + Type IDs: 83 + Filters: hltL2fL1sMu16Eta2p1L1f0L2Filtered20 + Paths (1/1): HLT_L2Mu20_eta2p1_NoVertex_v2(L,3) Collection: hltL3MuonCandidates::HLT + Type IDs: 83 + Filters: hlt2IsoMu20PFMHTPt80 hltL1HTT150singleMuL3PreFiltered15 hltL1HTT150singleMuL3PreFiltered5 hltL1Mu0HTT100L3Filtered5 hltL1Mu0HTT100ORL1Mu4HTT125L2QualL3MuFiltered40 hltL1Mu0HTT100ORL1Mu4HTT125L2QualL3MuFiltered60 hltL1Mu0HTT100ORMu4HTT125L3Filtered8 hltL1Mu10Eta2p1Jet20Jet12CentralCorrOrMu10erJetC32OrMu12erOrMu14erL3Mufiltered15Eta2p1 hltL1Mu4HTT125L3Filtered5 hltL3L1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL3Mufiltered12Eta2p1 hltL3Mu8DoubleJetC20L3Filtered8 hltL3crIsoL1sMu12Eta2p1L1f0L2f12QL3f15QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu14Eta2p1L1f0L2f16QL3f20L3crIsoRhoFiltered0p15 hltL3crIsoL1sMu14erORMu16erL1f0L2f14QL3f17QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f18QL3crIsoFiltered10 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f18QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f20L3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f20QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f30QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f34QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f40QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16Eta2p4L1f0L2f16QL3f18QL3crIsoFiltered10 hltL3crIsoL1sMu16L1f0L2f16QL3f20QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu16L1f0L2f16QL3f30QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMu7Eta2p1L1f0L2f7QL3f8QL3crIsoRhoFiltered0p15 hltL3crIsoL1sMuOpenCandidateL1f0L2f3L3f12L3crIsoFiltered12 hltL3crIsoL1sSingleMu7Eta2p1L1f0L2f7QL3f8QL3crIsoRhoFiltered0p15 hltL3fL1sMu10MuOpenOR3p5L1f0L2f10L3Filtered17 hltL3fL1sMu12Eta2p1L1f0L2f12QL3Filtered15Q hltL3fL1sMu12L3Filtered17 hltL3fL1sMu14erORMu16erL1f0L2f14QL3Filtered17Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered18Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered24Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered30Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered34Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered40 hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered40Q hltL3fL1sMu16Eta2p1L1f0L2f16QL3Filtered50Q hltL3fL1sMu16Eta2p4L1f0L2f16QL3Filtered18Q hltL3fL1sMu16L1f0L2f16QL3Filtered20Q hltL3fL1sMu16L1f0L2f16QL3Filtered24Q hltL3fL1sMu16L1f0L2f16QL3Filtered30Q hltL3fL1sMu16L1f0L2f16QL3Filtered40Q hltL3fL1sMu16erL3Filtered20 hltL3fL1sMu3L3Filtered5 hltL3fL1sMu3L3Filtered8 hltL3fL1sMu7Eta2p1L1f0L2f7QL3Filtered8Q hltL3fL1sMu7L1fEta2p1L2fEta2p1f7L3FilteredEta2p1Filtered15 hltL3fL1sMu7L3Filtered12 hltL3fL1sSingleMu7Eta2p1L1f0L2f7QL3Filtered8Q hltL3pfL1DoubleMu10MuOpenOR3p5L1f0L2pf0L3PreFiltered8 hltL3reliso1p0mufiltermu20 hltL3reliso1p0mufiltermu5 hltMu15TkMu5DCAL3Filtered15 hltMu15TkMu5TrackMassFilteredOnia hltMu5L2Mu3L3Filtered5 hltMu5TrackJpsiL3Filtered3 hltSingleMuOpenCandidateL3Filtered12 hltSingleMuOpenCandidateL3Filtered5 hltSingleMuOpenIsoCenJetL3crIsoRhoFiltered0p15 + Paths (47/38): HLT_IsoMu20_WCandPt80_v5(L,3) HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_Mu60_PFNoPUHT350_v5(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(L,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(L,3) HLT_Mu15_eta2p1_DiCentral_20_v2(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(L,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(L,3) HLT_Mu12_eta2p1_DiCentral_20_v9(L,3) HLT_Mu8_DiJet30_v8(L,3) HLT_Mu8_TriJet30_v8(L,3) HLT_Mu8_QuadJet30_v8(L,3) HLT_IsoMu15_eta2p1_L1ETM20_v8(L,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(*,3) HLT_IsoMu20_eta2p1_v8(L,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(*,3) HLT_IsoMu24_eta2p1_v16(L,3) HLT_IsoMu30_eta2p1_v16(L,3) HLT_IsoMu34_eta2p1_v14(L,3) HLT_IsoMu40_eta2p1_v11(L,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_IsoMu24_v18(L,3) HLT_IsoMu30_v12(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(L,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(L,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(L,3) HLT_Mu15_eta2p1_L1ETM20_v6(L,3) HLT_Mu17_v6(L,3) HLT_Mu24_eta2p1_v6(L,3) HLT_Mu30_eta2p1_v6(L,3) HLT_Mu40_eta2p1_v12(L,3) HLT_Mu50_eta2p1_v9(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_Mu24_v17(L,3) HLT_Mu30_v17(L,3) HLT_Mu40_v15(L,3) HLT_RelIso1p0Mu20_v4(L,3) HLT_Mu5_v21(L,3) HLT_RelIso1p0Mu5_v7(L,3) HLT_Mu8_v19(L,3) HLT_Mu15_eta2p1_v6(L,3) HLT_Mu12_v19(L,3) DST_Mu5_HT250_v5(L,3) Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (0/0): Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (0/0): Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (1/0): HLT_DiPFJetAve140_v11(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJet60L1FastJetCentralBPH hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltTriBJet20CentralL1FastJet + Paths (15/5): HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_RsqMR45_Rsq0p09_v5(L,3) HLT_RsqMR55_Rsq0p09_MR150_v6(L,3) HLT_RsqMR60_Rsq0p09_MR150_v6(L,3) HLT_RsqMR65_Rsq0p09_MR150_v5(L,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJet60L1FastJetCentralBPH hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltTriBJet20CentralL1FastJet + Paths (15/5): HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_RsqMR45_Rsq0p09_v5(L,3) HLT_RsqMR55_Rsq0p09_MR150_v6(L,3) HLT_RsqMR60_Rsq0p09_MR150_v6(L,3) HLT_RsqMR65_Rsq0p09_MR150_v5(L,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet60L1FastJetCentralBPH hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDoubleCentralJet65L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet70L1FastJet hltQuadJet80L1FastJet + Paths (8/5): HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_RsqMR45_Rsq0p09_v5(L,3) HLT_RsqMR55_Rsq0p09_MR150_v6(L,3) HLT_RsqMR60_Rsq0p09_MR150_v6(L,3) HLT_RsqMR65_Rsq0p09_MR150_v5(L,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJetHbb hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadJet25HbbZbb hltTriBJet20CentralL1FastJet + Paths (6/0): HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJetHbb hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltQuadJet25HbbZbb hltTriBJet20CentralL1FastJet + Paths (6/0): HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJetHbb hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltTriBJet20CentralL1FastJet + Paths (6/0): HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltFilterL2EtCutSingleIsoPFTau35Trk20 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltFilterL2EtCutSingleIsoPFTau35Trk20 + Paths (0/0): Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV + Paths (0/0): Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltBLifetimeL3FilterHbbCSV hltDiJetBLifetimeL3FilterHbbZbbCSV hltSingleJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV05 + Paths (0/0): Collection: hltPFHT350MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT350MET100orMHT150 + Paths (1/1): HLT_PFNoPUHT350_PFMET100_v5(L,3) Collection: hltPFHT350MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT350MET100orMHT150 + Paths (1/1): HLT_PFNoPUHT350_PFMET100_v5(L,3) Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (3/3): HLT_PFNoPUHT350_v5(L,3) HLT_Mu40_PFNoPUHT350_v5(L,3) HLT_Mu60_PFNoPUHT350_v5(L,3) Collection: hltPFHT350PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT350PFMET45 + Paths (0/0): Collection: hltPFHT350PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT350PFMET50 + Paths (0/0): Collection: hltPFHT400MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT400MET100orMHT150 + Paths (1/1): HLT_PFNoPUHT400_PFMET100_v5(L,3) Collection: hltPFHT400MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT400MET100orMHT150 + Paths (1/1): HLT_PFNoPUHT400_PFMET100_v5(L,3) Collection: hltPFHT400PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET45 + Paths (0/0): Collection: hltPFHT400PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET50 + Paths (0/0): Collection: hltPFMET80MuORNoMu::HLT + Type IDs: 90 + Filters: hltPFMET80MuORNoMu + Paths (1/1): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(L,3) Collection: hltPFMET80MuORNoMu::HLT + Type IDs: 90 + Filters: hltPFMET80MuORNoMu + Paths (1/1): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(L,3) Collection: hltPFMETProducer::HLT + Type IDs: 90 + Filters: hlt2IsoMu20PFMHTPt80 hltPFMHT0 + Paths (1/1): HLT_IsoMu20_WCandPt80_v5(L,3) Collection: hltPFMETnoMu105::HLT + Type IDs: 90 + Filters: hltPFMETnoMu105 + Paths (1/1): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(L,3) Collection: hltPFMHT40HT350::HLT + Type IDs: 90 + Filters: hltPFMHT40HT350 + Paths (0/0): Collection: hltMet::HLT + Type IDs: 87 + Filters: hltMET100 hltMET120 hltMET35 hltMET40 hltMET50 hltMET65 hltMET70 hltMET75 hltMET80 + Paths (7/3): HLT_MET100_HBHENoiseCleaned_v2(*,3) HLT_MET120_v13(L,3) HLT_MET120_HBHENoiseCleaned_v7(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_MET80_v5(L,3) HLT_MET80_Parked_v5(L,3) Collection: hltMetClean::HLT + Type IDs: 87 + Filters: hltMETClean25 hltMETClean50 hltMETClean60 + Paths (2/2): HLT_MET100_HBHENoiseCleaned_v2(L,3) HLT_MET120_HBHENoiseCleaned_v7(L,3) Collection: hltIsolPixelTrackProdHE::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHE + Paths (0/0): Collection: hltL1extraParticles::HLT + Type IDs: -81 + Filters: hltDimuon0or33L1Filtered0 hltDimuon30L1Filtered0 hltDimuon33L1Filtered0 hltDimuonL1Filtered0 hltL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL1MuFiltered0Eta2p1 hltL1MuOpenL1Filtered0 hltL1sAlCaRPC hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleMu0 hltL1sL1DoubleMu0erHighQ hltL1sL1DoubleMu0erHighQORDoubleMu3er0erHighQWdEta22 hltL1sL1DoubleMu0erOR3erHighQ hltL1sL1DoubleMu0or33HighQ hltL1sL1DoubleMu10MuOpenORDoubleMu103p5 hltL1sL1DoubleMu30HighQ hltL1sL1DoubleMu33HighQ hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1Mu4HTT125 hltL1sL1Mu7erETM26 hltL1sL1Mu8DoubleJetC20 hltL1sL1SingleMu12 hltL1sL1SingleMu12erORSingleMu14er hltL1sL1SingleMu16er hltL1sL1SingleMu3 hltL1sL1SingleMu7 hltL1sL1SingleMuOpen hltL1sL1SingleMuOpenCandidate hltL1sMu12Eta2p1ETM20 hltL1sMu14Eta2p1 hltL1sMu14erORMu16er hltL1sMu16 hltL1sMu16Eta2p1 hltMu5L2Mu3L1Filtered0 hltMu5TrackJpsiL1Filtered0 hltRPCMuonNormaL1Filtered0 + Paths (52/7): HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_L1SingleMuOpen_v7(L,3) HLT_L1SingleMuOpen_AntiBPTX_v7(L,3) AlCa_RPCMuonNoHits_v9(L,3) AlCa_RPCMuonNormalisation_v9(L,3) HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_Mu60_PFNoPUHT350_v5(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_L1SingleMu12_v2(L,3) HLT_Mu17_v6(*,3) HLT_RelIso1p0Mu20_v4(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_RelIso1p0Mu5_v7(*,3) HLT_Mu12_v19(*,3) HLT_Mu15_eta2p1_v6(*,3) HLT_IsoMu15_eta2p1_L1ETM20_v8(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(*,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_Mu24_v17(*,3) HLT_Mu30_v17(*,3) HLT_Mu40_v15(*,3) HLT_IsoMu24_v18(*,3) HLT_IsoMu30_v12(*,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(*,3) HLT_IsoMu20_WCandPt80_v5(*,3) HLT_L2Mu20_eta2p1_NoVertex_v2(*,3) HLT_Mu24_eta2p1_v6(*,3) HLT_Mu30_eta2p1_v6(*,3) HLT_Mu40_eta2p1_v12(*,3) HLT_Mu50_eta2p1_v9(*,3) HLT_IsoMu20_eta2p1_v8(*,3) HLT_IsoMu24_eta2p1_v16(*,3) HLT_IsoMu30_eta2p1_v16(*,3) HLT_IsoMu34_eta2p1_v14(*,3) HLT_IsoMu40_eta2p1_v11(*,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (38/13): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_RsqMR45_Rsq0p09_v5(*,3) HLT_RsqMR55_Rsq0p09_MR150_v6(*,3) HLT_RsqMR60_Rsq0p09_MR150_v6(*,3) HLT_RsqMR65_Rsq0p09_MR150_v5(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_AlphaT0p53_v8(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT350_AlphaT0p52_v8(L,3) HLT_HT350_AlphaT0p53_v19(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (38/13): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_RsqMR45_Rsq0p09_v5(*,3) HLT_RsqMR55_Rsq0p09_MR150_v6(*,3) HLT_RsqMR60_Rsq0p09_MR150_v6(*,3) HLT_RsqMR65_Rsq0p09_MR150_v5(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_AlphaT0p53_v8(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT350_AlphaT0p52_v8(L,3) HLT_HT350_AlphaT0p53_v19(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (38/13): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_IsoMu12_DoubleCentralJet65_v5(*,3) HLT_RsqMR40_Rsq0p04_v6(*,3) HLT_RsqMR45_Rsq0p09_v5(*,3) HLT_RsqMR55_Rsq0p09_MR150_v6(*,3) HLT_RsqMR60_Rsq0p09_MR150_v6(*,3) HLT_RsqMR65_Rsq0p09_MR150_v5(*,3) HLT_IsoMu12_RsqMR30_Rsq0p04_MR200_v5(*,3) HLT_IsoMu12_RsqMR40_Rsq0p04_MR200_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_AlphaT0p53_v8(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT350_AlphaT0p52_v8(L,3) HLT_HT350_AlphaT0p53_v19(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -87 + Filters: hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1ETM100 hltL1sL1ETM30 hltL1sL1ETM36ORETM40 hltL1sL1ETM36ORETM40ORETM50 hltL1sL1ETM36or40 hltL1sL1ETM40 hltL1sL1ETM70 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1Mu7erETM26 hltL1sMu12Eta2p1ETM20 + Paths (13/4): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_L1ETM100_v2(L,3) HLT_L1ETM30_v2(L,3) HLT_MET80_v5(*,3) HLT_MET80_Parked_v5(*,3) HLT_MET100_HBHENoiseCleaned_v2(*,3) HLT_MET120_v13(*,3) HLT_MET120_HBHENoiseCleaned_v7(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_L1ETM40_v2(L,3) HLT_L1ETM70_v2(L,3) HLT_IsoMu15_eta2p1_L1ETM20_v8(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (0/0): Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu4HTT125 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (14/8): HLT_PFNoPUHT350_v5(*,3) HLT_PFNoPUHT350_PFMET100_v5(*,3) HLT_PFNoPUHT400_PFMET100_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_AlphaT0p53_v8(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT350_AlphaT0p52_v8(L,3) HLT_HT350_AlphaT0p53_v19(L,3) HLT_Mu40_PFNoPUHT350_v5(*,3) HLT_Mu60_PFNoPUHT350_v5(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltCentralPFJet80 hltDiCentralPFJet25 hltDiPFJetAve140 hltDiPFJetAve40 hltDiPFJetAve80 hltPFNHEF95Filter + Paths (4/3): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_DiPFJetAve140_v11(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltCentralPFJet80 hltDiCentralPFJet25 hltDiPFJetAve140 hltDiPFJetAve40 hltDiPFJetAve80 hltIsoMu18eta2p4CentralPFJet30MuCleaned hltIsoMu18eta2p4DiCentralPFJet25MuCleaned hltIsoMu20eta2p1CentralPFJet80MuCleaned hltMu18eta2p4CentralPFJet30MuCleaned hltMu18eta2p4DiCentralPFJet25MuCleaned + Paths (7/6): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_DiPFJetAve140_v11(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(L,3) HLT_IsoMu20_eta2p1_CentralPFJet80_v10(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet60 hltDiCentralPFJet25 hltIsoMu18eta2p4CentralPFJet30MuCleaned hltIsoMu18eta2p4DiCentralPFJet25MuCleaned hltMu18eta2p4CentralPFJet30MuCleaned hltMu18eta2p4DiCentralPFJet25MuCleaned + Paths (2/2): HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet25 hltIsoMu18eta2p4CentralPFJet30MuCleaned hltIsoMu18eta2p4DiCentralPFJet25MuCleaned hltMu18eta2p4CentralPFJet30MuCleaned hltMu18eta2p4DiCentralPFJet25MuCleaned + Paths (2/2): HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet25 hltIsoMu18eta2p4CentralPFJet30MuCleaned hltIsoMu18eta2p4DiCentralPFJet25MuCleaned hltMu18eta2p4CentralPFJet30MuCleaned hltMu18eta2p4DiCentralPFJet25MuCleaned + Paths (2/2): HLT_IsoMu18_CentralPFJet30_CentralPFJet25_v2(L,3) HLT_Mu18_CentralPFJet30_CentralPFJet25_v2(L,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 86 0 + Filters: hltDiCentralPFJet50NoPU hltIsoMu172p1CentralBPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet45MuCleaned hltIsoMu172p1DiCentralPFNoPUJet30MuCleaned hltIsoMu172p1DiCentralPFNoPUJet35MuCleaned hltIsoMu172p1TriCentralPFNoPUJet25MuCleaned hltIsoMu172p1TriCentralPFNoPUJet30MuCleaned hltMu172p1CentralBPFNoPUJet30MuCleaned hltMu172p1CentralPFNoPUJet45MuCleaned hltMu172p1DiCentralPFNoPUJet35MuCleaned hltMu172p1TriCentralPFNoPUJet25MuCleaned + Paths (6/5): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(L,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 86 + Filters: hltIsoMu172p1CentralBPFNoPUJet30MuCleaned hltMu172p1CentralBPFNoPUJet30MuCleaned + Paths (0/0): Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 86 0 + Filters: hltDiCentralPFJet50NoPU hltIsoMu172p1CentralBPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet45MuCleaned hltIsoMu172p1DiCentralPFNoPUJet30MuCleaned hltIsoMu172p1DiCentralPFNoPUJet35MuCleaned hltIsoMu172p1TriCentralPFNoPUJet25MuCleaned hltIsoMu172p1TriCentralPFNoPUJet30MuCleaned hltMu172p1CentralBPFNoPUJet30MuCleaned hltMu172p1CentralPFNoPUJet45MuCleaned hltMu172p1DiCentralPFNoPUJet35MuCleaned hltMu172p1TriCentralPFNoPUJet25MuCleaned + Paths (6/5): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(L,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 86 0 + Filters: hltDiCentralPFJet50NoPU hltIsoMu172p1CentralBPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet45MuCleaned hltIsoMu172p1DiCentralPFNoPUJet30MuCleaned hltIsoMu172p1DiCentralPFNoPUJet35MuCleaned hltIsoMu172p1TriCentralPFNoPUJet25MuCleaned hltIsoMu172p1TriCentralPFNoPUJet30MuCleaned hltMu172p1CentralBPFNoPUJet30MuCleaned hltMu172p1CentralPFNoPUJet45MuCleaned hltMu172p1DiCentralPFNoPUJet35MuCleaned hltMu172p1TriCentralPFNoPUJet25MuCleaned + Paths (6/5): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(L,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(L,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 86 0 + Filters: hltIsoMu172p1CentralBPFNoPUJet30MuCleaned hltIsoMu172p1CentralPFNoPUJet30MuCleaned hltIsoMu172p1DiCentralPFNoPUJet30MuCleaned hltIsoMu172p1TriCentralPFNoPUJet25MuCleaned hltIsoMu172p1TriCentralPFNoPUJet30MuCleaned hltMu172p1CentralBPFNoPUJet30MuCleaned hltMu172p1TriCentralPFNoPUJet25MuCleaned + Paths (5/3): HLT_IsoMu17_eta2p1_CentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_DiCentralPFNoPUJet30_v5(L,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) HLT_IsoMu17_eta2p1_TriCentralPFNoPUJet30_v5(L,3) HLT_Mu17_eta2p1_TriCentralPFNoPUJet45_35_25_v3(*,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (0/0): indx x y z rho chi2 ndf + 0 0.24 0.39 0.39 0.46 95 1.1e+02 + 1 0.24 0.4 0.4 0.46 37 70 + 2 0.25 0.39 0.39 0.46 43 60 + 3 0.24 0.39 0.39 0.46 24 30 + 4 0.26 0.39 0.39 0.47 19 17 + 5 0.24 0.39 0.39 0.46 10 10 + 6 0.24 0.38 0.38 0.45 3 8.8 + 7 0.25 0.39 0.39 0.46 8.2 9.2 + 8 0.24 0.39 0.39 0.46 8.3 8.6 + 9 0.23 0.39 0.39 0.46 4.4 3.3 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002024 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 7th record. Run 1, Event 7002028, LumiSection 70021 at 19-Sep-2014 22:10:04.671 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002028 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002028 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltL1SeededRecoEcalCandidate::HLT + Type IDs: 81 92 + Filters: hltEG20CaloIdVLHEFilter hltEG26CaloId10Iso50HcalIsoLastFilter hltEG26HE10LastFilter hltEG26R9Id85LastFilter hltEG30CaloIdVLHEFilter hltEG30CaloIdVTHEFilterL1EG22 hltEG36CaloId10Iso50HcalIsoLastFilter hltEG36HE10LastFilter hltEG36R9Id85LastFilter hltEG40CaloIdLHEFilter hltEG48HEVTFilter hltEG53HEVTFilter hltEG60CaloIdLHEFilter hltEG70CaloIdXLHEFilter hltEG70HEFilter hltEG80HEFilter hltEle13WP90ClusterShapeFilter hltEle13WP90NoIsoHEFilter hltEle13WP90NoIsoPixelMatchFilter hltEle13WP90RhoEcalIsoFilter hltEle13WP90RhoHEFilter hltEle13WP90RhoHcalIsoFilter hltEle13WP90RhoPixelMatchFilter hltEle17CaloIdLCaloIsoVLPixelMatchFilter hltEle22CaloIdLCaloIsoVLPixelMatchFilter hltEle22WP90NoIsoHEFilter hltEle22WP90NoIsoPixelMatchFilter hltEle22WP90RhoClusterShapeFilter hltEle22WP90RhoEcalIsoFilter hltEle22WP90RhoHEFilter hltEle22WP90RhoHcalIsoFilter hltEle22WP90RhoPixelMatchFilter hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17PixelMatchFilter hltEle33CaloIdLPixelMatchFilter hltEle33CaloIdTPixelMatchFilter hltEle80CaloIdVTGsfTrkIdTDPhiFilter hltEle8CaloIdLCaloIsoVLPixelMatchFilter hltEle90CaloIdVTGsfTrkIdTDPhiFilter hltMu7Ele7CaloIdTPixelMatchFilter hltPhoton30HEFilter hltPhoton50CaloIdVLHEFilter hltPhoton75CaloIdVLHEFilter hltPhoton90CaloIdVLHEFilter hltSingleEle13WP90RhoClusterShapeFilter hltSingleEle13WP90RhoEcalIsoFilter hltSingleEle13WP90RhoHEFilter hltSingleEle13WP90RhoHcalIsoFilter hltSingleEle13WP90RhoPixelMatchFilter + Paths (16/13): HLT_Photon20_CaloIdVL_v5(L,3) HLT_Photon30_CaloIdVL_v15(L,3) HLT_Ele30_CaloIdVT_TrkIdT_v7(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) HLT_Photon60_CaloIdL_HT300_v5(L,3) HLT_Photon70_CaloIdXL_PFNoPUHT400_v5(*,3) HLT_Ele17_CaloIdL_CaloIsoVL_v18(L,3) HLT_Ele22_CaloIdL_CaloIsoVL_v7(L,3) HLT_Ele80_CaloIdVT_GsfTrkIdT_v3(L,3) HLT_Ele8_CaloIdL_CaloIsoVL_v18(L,3) HLT_Ele90_CaloIdVT_GsfTrkIdT_v3(L,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(L,3) HLT_Photon30_v2(L,3) HLT_Photon50_CaloIdVL_v11(L,3) HLT_Photon75_CaloIdVL_v14(L,3) HLT_Photon90_CaloIdVL_v11(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 81 92 + Filters: hltEG10CaloId10Iso50TrackIsoLastFilterUnseeded hltEG10R9Id85LastFilterUnseeded hltEG18HE10DoubleLastFilterUnseeded hltEG22HE10DoubleLastFilterUnseeded hltEG40CaloIdLHEDoubleFilterUnseeded hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltEleAnyWP80PixelMatchElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hlt2ElectronPFMHTPt80 hltEle24WP80TrackIsoFilter hltEle27WP80PFMT50PFMTFilter hltEle27WP80TrackIsoFilter + Paths (8/3): HLT_Ele27_WP80_WCandPt80_v11(L,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_v3(*,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_v3(*,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_CentralPFJet30_v3(*,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_PFMET20_v3(*,3) HLT_Ele27_WP80_PFMET_MT50_v9(L,3) HLT_Ele27_WP80_v13(L,3) HLT_Ele27_WP80_CentralPFJet80_v11(*,3) Collection: hltPixelMatch3HitElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltEle17CaloIdVTCaloIsoVTTrkIdTTrkIsoVTEle8TrackIsoFilter hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoFilter hltEle20CaloIdVTCaloIsoVTTrkIdTTrkIsoVTSC4TrackIsoFilter hltEle23TightIdLooseIsoTrackIsoFilter hltEle27TightIdLooseIsoTrackIsoFilter hltEle5SC5JpsiTrackIsolFilter hltEle8TightIdLooseIsoTrackIsoFilter hltMu8Ele17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter + Paths (5/3): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v7(L,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(L,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(L,3) Collection: hltPixelMatch3HitElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltEle17CaloIdVTCaloIsoVTTrkIdTTrkIsoVTEle8TrackIsoFilter hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoFilter hltEle20CaloIdVTCaloIsoVTTrkIdTTrkIsoVTSC4TrackIsoFilter hltEle23TightIdLooseIsoTrackIsoFilter hltEle27TightIdLooseIsoTrackIsoFilter hltEle5SC5JpsiTrackIsolFilter hltEle8TightIdLooseIsoTrackIsoFilter hltMu8Ele17CaloIdTCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter + Paths (5/3): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v7(L,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(L,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(L,3) Collection: hltPixelMatch3HitElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle17TightIdLooseIsoEle8TightIdLooseIsoTrackIsoFilter hltEle23TightIdLooseIsoTrackIsoFilter hltEle27TightIdLooseIsoTrackIsoFilter hltEle8TightIdLooseIsoTrackIsoFilter + Paths (2/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(L,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) Collection: hltPixelMatchElectronsActivity::HLT + Type IDs: 82 + Filters: hltEle12CaloIdTTrkIdVLCaloIsoVLTrkIsoVLTrackIsoFilterUnseeded hltEle15CaloIdTTrkIdTCaloIsoVLTrkIsoVLFilterUnseeded hltEle5CaloIdTTrkIdTCaloIsoVLTrkIsoVLFilterUnseeded hltEle8CaloIdLTrkIdVLCaloIsoVLTrkIsoVLTrackIsolFilterUnseeded hltMu8Ele8CaloIdTTrkIdVLMass8Filter hltSingleElectronEt8CaloIdTTrkIdVLNoCandDphiFilter + Paths (4/2): HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(L,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(L,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) Collection: hltPixelMatchElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle13WP90NoIsoDetaFilter hltEle13WP90NoIsoDphiFilter hltEle13WP90NoIsoOneOEMinusOneOPFilter hltEle13WP90RhoDetaFilter hltEle13WP90RhoDphiFilter hltEle13WP90RhoOneOEMinusOneOPFilter hltEle13WP90RhoTrackIsoFilter hltEle22WP90NoIsoDetaFilter hltEle22WP90NoIsoDphiFilter hltEle22WP90NoIsoOneOEMinusOneOPFilter hltEle22WP90RhoDetaFilter hltEle22WP90RhoDphiFilter hltEle22WP90RhoOneOEMinusOneOPFilter hltEle22WP90RhoTrackIsoFilter hltEle25CaloIdVTTrkIdTCaloIsoTTrkIsoTTrackIsoFilter hltEle25CaloIdVTTrkIdVLCaloIsoVLTrkIsoTTrackIsoFilter hltEle27CaloIdLCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltEle30CaloIdVTTrkIdTDphiFilter hltEle32CaloIdLCaloIsoVLTrkIdVLTrkIsoVLTrackIsoFilter hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsoFilter hltEle8CaloIdTTrkIdTL1EG8DoubleJet20CentralDphiFilter hltEle8CaloIdTTrkIdVLDphiFilter hltEle8CaloIdTTrkIdVLDphiFilterL1Mu5DoubleEG5 hltEle8CaloIdTTrkIdVLEG7DphiFilter hltSingleEle13WP90RhoDetaFilter hltSingleEle13WP90RhoDphiFilter hltSingleEle13WP90RhoOneOEMinusOneOPFilter hltSingleEle13WP90RhoTrackIsoFilter + Paths (16/5): HLT_Ele25_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_CentralPFNoPUJet30_v10(*,3) HLT_Ele25_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_CentralPFNoPUJet30_BTagIPIter_v11(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(*,3) HLT_Ele27_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(L,3) HLT_Ele30_CaloIdVT_TrkIdT_v7(L,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdVL_v6(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(*,3) HLT_Ele8_CaloIdT_TrkIdVL_EG7_v3(L,3) Collection: hltPixelMatchElectronsL1Seeded::HLT + Type IDs: 82 + Filters: hltEle13WP90NoIsoOneOEMinusOneOPFilter hltEle13WP90RhoOneOEMinusOneOPFilter hltEle22WP90NoIsoOneOEMinusOneOPFilter hltEle22WP90RhoOneOEMinusOneOPFilter hltSingleEle13WP90RhoOneOEMinusOneOPFilter + Paths (0/0): Collection: hltL2MuonCandidates::HLT + Type IDs: 83 + Filters: hltL1HTT150singleMuL2PreFiltered0 hltL1HTT150singleMuL2PreFiltered10 hltL1Mu0EG5L2MuFiltered0 hltL1Mu0HTT100L2Filtered0 hltL1Mu0HTT100ORL1Mu4HTT125L2QualMuFiltered16 hltL1Mu0HTT100ORMu4HTT125L2Filtered0 hltL1Mu12EG7L2MuFiltered0 hltL1Mu12EG7ORL1MuOpenEG12L2MuFiltered0 hltL1Mu3p5EG12L2Filtered12 hltL1Mu4HTT125L2Filtered0 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L2Filtered5 hltL2L1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL2MuFiltered10Eta2p1 hltL2Mu5DoubleEG5L2Filtered5 hltL2fL1sMu12Eta2p1L1f0L2Filtered12Q hltL2fL1sMu12L2Filtered12 hltL2fL1sMu14Eta2p1L1f0L2Filtered14Q hltL2fL1sMu14erORMu16erL1f0L2Filtered14Q hltL2fL1sMu16Eta2p1L1f0L2Filtered16Q hltL2fL1sMu16Eta2p4L1f0L2Filtered16Q hltL2fL1sMu16L1f0L2Filtered16Q hltL2fL1sMu16erL2Filtered16 hltL2fL1sMu3L2Filtered3 hltL2fL1sMu7Eta2p1L1f0L2Filtered7Q hltL2fL1sMu7L1fEta2p1L2FilteredEta2p1Filtered7 hltL2fL1sMu7L2Filtered7 hltL2fL1sSingleMu7Eta2p1L1f0L2Filtered7Q hltMu15TkMu5DCAL2Filtered10 hltMu5TrackJpsiL2Filtered3 hltSingleMuOpenCandidateL2Filtered0 hltSingleMuOpenCandidateL2Filtered3 + Paths (7/0): HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) DST_Mu5_HT250_v5(*,3) Collection: hltL3MuonCandidates::HLT + Type IDs: 83 + Filters: hltL1HTT150singleMuL3PreFiltered5 hltL1Mu0EG5L3MuFiltered7 hltL1Mu0HTT100L3Filtered5 hltL1Mu0HTT100ORMu4HTT125L3Filtered8 hltL1Mu4HTT125L3Filtered5 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L3Filtered8 hltL3Mu8DoubleJetC20L3Filtered8 hltL3fL1sMu3L3Filtered5 hltL3fL1sMu3L3Filtered8 hltL3fL1sMu7Eta2p1L1f0L2f7QL3Filtered8Q hltL3fL1sSingleMu7Eta2p1L1f0L2f7QL3Filtered8Q hltMu5DoubleEG5L3Filtered8 hltMu5Track1JpsiPixelMassFiltered hltMu5TrackJpsiL3Filtered3 hltMu8Ele8CaloIdTTrkIdVLMass8Filter hltSingleMuOpenCandidateL3Filtered5 + Paths (10/6): HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu8_DiJet30_v8(L,3) HLT_Mu8_TriJet30_v8(L,3) HLT_Mu8_QuadJet30_v8(L,3) HLT_Mu5_v21(L,3) HLT_Mu8_v19(L,3) DST_Mu5_HT250_v5(L,3) Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (0/0): Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (0/0): Collection: hltBLifetimeL25JetsHbbVBF::HLT + Type IDs: 86 + Filters: hltCSV0p6L25FilterHbbVBF hltCSV0p8L3FilterHbbVBF + Paths (0/0): Collection: hltBSoftMuonDiJet20L1FastJetL25Jets::HLT + Type IDs: 86 + Filters: hltBSoftMuonDiJet20L1FastJetMu5L3FilterByDR + Paths (1/1): HLT_BTagMu_DiJet20_Mu5_v7(L,3) Collection: hltBSoftMuonDiJet40L1FastJetL25Jets::HLT + Type IDs: 86 + Filters: hltBSoftMuonDiJet40L1FastJetMu5L3FilterByDR + Paths (1/1): HLT_BTagMu_DiJet40_Mu5_v7(L,3) Collection: hltBSoftMuonDiJet70L1FastJetL25Jets::HLT + Type IDs: 86 + Filters: hltBSoftMuonDiJet70L1FastJetMu5L3FilterByDR + Paths (1/1): HLT_BTagMu_DiJet70_Mu5_v7(L,3) Collection: hltBSoftMuonJet20L1FastJetL25JetsBPH::HLT + Type IDs: 86 + Filters: hltBSoftMuonJet20L1FastJetMu5L3FilterByDRBPH + Paths (1/1): HLT_BTagMu_Jet20_Mu4_v3(L,3) Collection: hltBSoftMuonJet60L1FastJetL25JetsBPH::HLT + Type IDs: 86 + Filters: hltBSoftMuonJet60L1FastJetMu5L3FilterByDRBPH + Paths (1/1): HLT_BTagMu_Jet60_Mu4_v3(L,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional + Paths (0/0): Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (0/0): Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJet60L1FastJetCentralBPH hltBJetHbbVBF hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleJet30L1FastJet hltTriBJet20CentralL1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (16/7): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_BTagMu_Jet20_Mu4_v3(*,3) HLT_BTagMu_Jet60_Mu4_v3(*,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) HLT_QuadJet75_55_35_20_VBF_v2(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet110L1FastJetCentral hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJet60L1FastJetCentralBPH hltBJetHbbVBF hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSingleJet30L1FastJet hltTriBJet20CentralL1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (16/7): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_BTagMu_Jet20_Mu4_v3(*,3) HLT_BTagMu_Jet60_Mu4_v3(*,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) HLT_QuadJet75_55_35_20_VBF_v2(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBDiJet70L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJet60L1FastJetCentralBPH hltBJetHbbVBF hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSingleJet30L1FastJet hltTriBJet20CentralL1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (16/7): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_BTagMu_Jet20_Mu4_v3(*,3) HLT_BTagMu_Jet60_Mu4_v3(*,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) HLT_QuadJet75_55_35_20_VBF_v2(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBDiJet40L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJet40CentralL1FastJet hltBJetHbbVBF hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDoubleBJet40Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleJet30Central hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadJet25HbbZbb hltQuadJet30Central hltSingleJet30L1FastJet hltTriBJet20CentralL1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (12/7): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_Jet20_Mu4_v3(*,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) HLT_QuadJet75_55_35_20_VBF_v2(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJetHbbVBF hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDoubleJet30Central hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltQuadJet25HbbZbb hltQuadJet30Central hltSingleJet30L1FastJet hltTriBJet20CentralL1FastJet hltTripleJet30Central hltTripleL2Jets30eta3 + Paths (8/5): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_Jet20_Mu4_v3(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(L,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) HLT_QuadJet75_55_35_20_VBF_v2(L,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(L,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(L,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBDiJet20L1FastJetCentral hltBJet20L1FastJetCentralBPH hltBJetHbbVBF hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltTriBJet20CentralL1FastJet + Paths (4/1): HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_Jet20_Mu4_v3(*,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) HLT_QuadJet75_55_35_20_VBF_v2(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 + Filters: hltBJetHbbVBF + Paths (0/0): Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele17CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltCleanEle8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLFromAK5CorrJetsJet30::HLT + Type IDs: 85 + Filters: hltJet30Ele8CaloIdTTrkIdVLCaloIsoVLTrkIsoVLRemoved + Paths (1/1): HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(L,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltBLifetimeL25FilterbbPhi1BL1FastJetFastPV hltBLifetimeL25FilterbbPhiL1FastJetFastPV hltBLifetimeL3FilterbbPhi1BL1FastJetFastPV hltBLifetimeL3FilterbbPhi1BLooseL1FastJetFastPV hltBLifetimeL3FilterbbPhiL1FastJetFastPV hltDiJetBLifetimeL3FilterHbbZbbCSV hltSingleJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV05 + Paths (2/2): HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(L,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltBLifetimeL25FilterbbPhi1BL1FastJetFastPV hltBLifetimeL25FilterbbPhiL1FastJetFastPV + Paths (2/0): HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) Collection: hltEle5CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET45::HLT + Type IDs: 90 + Filters: hltEle5CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET45 + Paths (0/0): Collection: hltEle5CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET50::HLT + Type IDs: 90 + Filters: hltEle5CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET50 + Paths (0/0): Collection: hltElectron15CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET45::HLT + Type IDs: 90 + Filters: hltElectron15CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET45 + Paths (0/0): Collection: hltElectron15CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET50::HLT + Type IDs: 90 + Filters: hltElectron15CaloIdTCaloIsoVLTrkIdTTrkIsoVLCleanedPFHT350NoPUPFMET50 + Paths (0/0): Collection: hltElectron40CaloIdTTrkIdTCleanedPFHT300NoPU::HLT + Type IDs: 90 + Filters: hltElectron40CaloIdTTrkIdTCleanedPFHT300NoPU + Paths (1/1): HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v4(L,3) Collection: hltElectron60CaloIdTTrkIdTCleanedPFHT300NoPU::HLT + Type IDs: 90 + Filters: hltElectron60CaloIdTTrkIdTCleanedPFHT300NoPU + Paths (1/1): HLT_CleanPFNoPUHT300_Ele60_CaloIdVT_TrkIdT_v4(L,3) Collection: hltPFHT175NoPU::HLT + Type IDs: 90 + Filters: hltPFHT175NoPU + Paths (1/1): HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(L,3) Collection: hltPFHT225NoPU::HLT + Type IDs: 90 + Filters: hltPFHT225NoPU + Paths (1/1): HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(L,3) Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (1/1): HLT_PFNoPUHT350_v5(L,3) Collection: hltPFHT400::HLT + Type IDs: 90 + Filters: hltPFHT400 + Paths (1/1): HLT_Photon70_CaloIdXL_PFNoPUHT400_v5(L,3) Collection: hltPFHT400PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET45 + Paths (0/0): Collection: hltPFHT400PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET50 + Paths (0/0): Collection: hltPFHT500::HLT + Type IDs: 90 + Filters: hltPFHT500 + Paths (0/0): Collection: hltPFMETProducer::HLT + Type IDs: 90 + Filters: hlt2ElectronPFMHTPt80 hltPFMET20Filter hltPFMHT0 + Paths (2/2): HLT_Ele27_WP80_WCandPt80_v11(L,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_PFMET20_v3(L,3) Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (0/0): Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (0/0): Collection: hltL1extraParticles:Isolated:HLT + Type IDs: -83 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1IsoEG12erETM36 hltL1sL1Mu0EG5 hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1SingleEG12 hltL1sL1SingleEG20ORL1SingleEG22 hltL1sL1SingleEG22 hltL1sL1SingleEG24 hltL1sL1SingleEG30 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1SingleIsoEG18erORIsoEG20erOREG22 hltL1sL1SingleIsoEG18erORL1SingleIsoEG20er + Paths (47/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Photon20_CaloIdVL_v5(*,3) HLT_L1SingleEG12_v6(L,3) HLT_Ele17_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v7(*,3) HLT_Ele22_CaloIdL_CaloIsoVL_v7(*,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Photon30_v2(*,3) HLT_Photon30_CaloIdVL_v15(*,3) HLT_Photon50_CaloIdVL_v11(*,3) HLT_Photon75_CaloIdVL_v14(*,3) HLT_Photon90_CaloIdVL_v11(*,3) HLT_Ele27_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(*,3) HLT_Ele27_WP80_v13(*,3) HLT_Ele27_WP80_PFMET_MT50_v9(*,3) HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(*,3) HLT_Ele80_CaloIdVT_GsfTrkIdT_v3(*,3) HLT_Ele90_CaloIdVT_GsfTrkIdT_v3(*,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_v3(*,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_v3(*,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_CentralPFJet30_v3(*,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_PFMET20_v3(*,3) HLT_Ele25_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_CentralPFNoPUJet30_v10(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(*,3) HLT_Ele25_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_CentralPFNoPUJet30_BTagIPIter_v11(*,3) HLT_Ele27_WP80_CentralPFJet80_v11(*,3) HLT_Ele27_WP80_WCandPt80_v11(*,3) HLT_Ele30_CaloIdVT_TrkIdT_v7(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) HLT_Photon60_CaloIdL_HT300_v5(*,3) HLT_Photon70_CaloIdXL_PFNoPUHT400_v5(*,3) HLT_L1SingleEG5_v6(L,3) HLT_Ele8_CaloIdT_TrkIdVL_v6(*,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(*,3) HLT_Ele8_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele8_CaloIdT_TrkIdVL_EG7_v3(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1Mu0EG5 hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1SingleEG12 hltL1sL1SingleEG20ORL1SingleEG22 hltL1sL1SingleEG22 hltL1sL1SingleEG24 hltL1sL1SingleEG30 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1SingleIsoEG18erORIsoEG20erOREG22 + Paths (47/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Photon20_CaloIdVL_v5(*,3) HLT_L1SingleEG12_v6(L,3) HLT_Ele17_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v7(*,3) HLT_Ele22_CaloIdL_CaloIsoVL_v7(*,3) HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) HLT_Photon30_v2(*,3) HLT_Photon30_CaloIdVL_v15(*,3) HLT_Photon50_CaloIdVL_v11(*,3) HLT_Photon75_CaloIdVL_v14(*,3) HLT_Photon90_CaloIdVL_v11(*,3) HLT_Ele27_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(*,3) HLT_Ele27_WP80_v13(*,3) HLT_Ele27_WP80_PFMET_MT50_v9(*,3) HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v12(*,3) HLT_Ele80_CaloIdVT_GsfTrkIdT_v3(*,3) HLT_Ele90_CaloIdVT_GsfTrkIdT_v3(*,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_v3(*,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_v3(*,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_CentralPFJet30_v3(*,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_PFMET20_v3(*,3) HLT_Ele25_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_CentralPFNoPUJet30_v10(*,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(*,3) HLT_Ele25_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_CentralPFNoPUJet30_BTagIPIter_v11(*,3) HLT_Ele27_WP80_CentralPFJet80_v11(*,3) HLT_Ele27_WP80_WCandPt80_v11(*,3) HLT_Ele30_CaloIdVT_TrkIdT_v7(*,3) HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) HLT_Photon60_CaloIdL_HT300_v5(*,3) HLT_Photon70_CaloIdXL_PFNoPUHT400_v5(*,3) HLT_L1SingleEG5_v6(L,3) HLT_Ele8_CaloIdT_TrkIdVL_v6(*,3) HLT_Ele8_CaloIdT_TrkIdVL_Jet30_v8(*,3) HLT_Ele8_CaloIdL_CaloIsoVL_v18(*,3) HLT_Ele8_CaloIdT_TrkIdVL_EG7_v3(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16(*,3) HLT_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Jet30_v8(*,3) Collection: hltL1extraParticles::HLT + Type IDs: -81 + Filters: hltL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL1MuFiltered0Eta2p1 hltL1MuOpenL1Filtered0 hltL1sAlCaEcalPi0Eta hltL1sAlCaRPC hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1Mu0EG5 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu4HTT125 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1Mu7erETM26 hltL1sL1Mu8DoubleJetC20 hltL1sL1SingleMu12 hltL1sL1SingleMu12erORSingleMu14er hltL1sL1SingleMu16er hltL1sL1SingleMu3 hltL1sL1SingleMu7 hltL1sL1SingleMuOpen hltL1sL1SingleMuOpenCandidate hltL1sMu12Eta2p1ETM20 hltL1sMu14Eta2p1 hltL1sMu14erORMu16er hltL1sMu16 hltL1sMu16Eta2p1 hltMu5TrackJpsiL1Filtered0 hltRPCMuonNoTriggersL1Filtered0 hltRPCMuonNormaL1Filtered0 + Paths (22/8): HLT_L1SingleMuOpen_v7(L,3) HLT_L1SingleMuOpen_AntiBPTX_v7(L,3) AlCa_RPCMuonNoTriggers_v9(L,3) AlCa_RPCMuonNoHits_v9(L,3) AlCa_RPCMuonNormalisation_v9(L,3) HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Mu7_Ele7_CaloIdT_CaloIsoVL_v8(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_BTagMu_Jet20_Mu4_v3(*,3) HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_Jet60_Mu4_v3(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v10(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_L1SingleMu12_v2(L,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (30/11): HLT_HcalNZS_v10(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_v6(L,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_QuadJet75_55_35_20_VBF_v2(*,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu3JetC16WdEtaPhi2 hltL1sL1Mu3JetC52WdEtaPhi2 hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (35/11): HLT_HcalNZS_v10(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_v6(L,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_BTagMu_Jet20_Mu4_v3(*,3) HLT_BTagMu_DiJet20_Mu5_v7(*,3) HLT_BTagMu_DiJet40_Mu5_v7(*,3) HLT_BTagMu_Jet60_Mu4_v3(*,3) HLT_BTagMu_DiJet70_Mu5_v7(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_QuadJet75_55_35_20_VBF_v2(*,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (24/6): HLT_HcalNZS_v10(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_QuadJet75_55_35_20_VBF_v2(*,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (30/11): HLT_HcalNZS_v10(L,3) HLT_DiJet40Eta2p6_BTagIP3DFastPV_v8(*,3) HLT_DiJet80Eta2p6_BTagIP3DFastPVLoose_v8(*,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_v6(L,3) HLT_Ele12_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_DoubleCentralJet65_v5(*,3) HLT_Ele8_CaloIdT_TrkIdT_DiJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_TriJet30_v19(*,3) HLT_Ele8_CaloIdT_TrkIdT_QuadJet30_v19(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_QuadJet75_55_35_20_VBF_v2(*,3) HLT_QuadPFJet78_61_44_31_VBF_v2(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sHcalNZS hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1SingleJet16 hltL1sL1SingleJet16FwdVeto5 + Paths (4/2): HLT_HcalNZS_v10(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -87 + Filters: hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1ETM30 hltL1sL1IsoEG12erETM36 hltL1sL1Mu7erETM26 hltL1sMu12Eta2p1ETM20 + Paths (1/1): HLT_L1ETM30_v2(L,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (0/0): Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sAlCaEcalPi0Eta hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu4HTT125 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (15/6): HLT_PFNoPUHT350_v5(*,3) HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v4(*,3) HLT_CleanPFNoPUHT300_Ele60_CaloIdVT_TrkIdT_v4(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) DST_Ele8_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_HT250_v6(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT175_v6(*,3) HLT_Mu8_Ele8_CaloIdT_TrkIdVL_Mass8_PFNoPUHT225_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve40 hltDiPFJetAve80 hltEle24WP80PFJet30PFJet25Deta3CentralPFJet30PFJetCollectionsVBFFilter hltPFJetDouble61HbbVBF hltPFJetQuad31HbbVBF hltPFJetSingle78HbbVBF hltPFJetTriple44HbbVBF + Paths (4/4): HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_CentralPFJet30_v3(L,3) HLT_QuadPFJet78_61_44_31_VBF_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve40 hltDiPFJetAve80 hltEle24WP80CentralPFJet35EleCleaned hltEle24WP80DiCentralPFJet25EleCleaned hltEle24WP80PFJet30PFJet25Deta3CentralPFJet30PFJetCollectionsVBFFilter hltEle24WP80PFJet30PFJet25Deta3PFJetCollectionsVBFFilter hltEle27WP80CentralPFJet80EleCleaned hltPFJetDouble61HbbVBF hltPFJetQuad31HbbVBF hltPFJetSingle78HbbVBF hltPFJetTriple44HbbVBF + Paths (8/7): HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_v3(L,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_PFMET20_v3(*,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_CentralPFJet30_v3(L,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_v3(L,3) HLT_Ele27_WP80_CentralPFJet80_v11(L,3) HLT_QuadPFJet78_61_44_31_VBF_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltEle24WP80CentralPFJet35EleCleaned hltEle24WP80DiCentralPFJet25EleCleaned hltEle24WP80PFJet30PFJet25Deta3CentralPFJet30PFJetCollectionsVBFFilter hltEle24WP80PFJet30PFJet25Deta3PFJetCollectionsVBFFilter hltEle27WP80CentralPFJet80EleCleaned hltPFJetDouble61HbbVBF hltPFJetQuad31HbbVBF hltPFJetSingle78HbbVBF hltPFJetTriple44HbbVBF + Paths (6/5): HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_v3(L,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_PFMET20_v3(*,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_CentralPFJet30_v3(L,3) HLT_Ele24_WP80_PFJet30_PFJet25_Deta3_v3(L,3) HLT_Ele27_WP80_CentralPFJet80_v11(L,3) HLT_QuadPFJet78_61_44_31_VBF_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltEle24WP80CentralPFJet35EleCleaned hltEle24WP80DiCentralPFJet25EleCleaned hltPFJetDouble61HbbVBF hltPFJetQuad31HbbVBF hltPFJetTriple44HbbVBF + Paths (3/2): HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_v3(L,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_PFMET20_v3(*,3) HLT_QuadPFJet78_61_44_31_VBF_v2(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltEle24WP80DiCentralPFJet25EleCleaned + Paths (2/1): HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_v3(L,3) HLT_Ele24_WP80_CentralPFJet35_CentralPFJet25_PFMET20_v3(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiPFNoPUJet25 + Paths (1/0): HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 86 0 + Filters: hltDiPFNoPUJet25 hltEle25CaloIdVTCaloIsoTTrkIdTTrkIsoTCentralBPFNoPUJet30EleCleaned hltEle25CaloIdVTCaloIsoTTrkIdTTrkIsoTCentralPFNoPUJet30EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet45EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTCentralPFNoPUJet50EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet30EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet35EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTDiCentralPFNoPUJet40EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet25EleCleaned hltEle25CaloIdVTCaloIsoVLTrkIdVLTrkIsoTTriCentralPFNoPUJet30EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet100EleCleaned hltEle30CaloIdVTTrkIdTDiCentralPFNoPUJet25EleCleaned + Paths (7/6): HLT_Ele30_CaloIdVT_TrkIdT_PFNoPUJet100_PFNoPUJet25_v9(L,3) HLT_Ele25_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_CentralPFNoPUJet30_BTagIPIter_v11(*,3) HLT_Ele25_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_CentralPFNoPUJet30_v10(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet45_35_25_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet50_40_30_v6(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_DiCentralPFNoPUJet30_v4(L,3) HLT_Ele25_CaloIdVT_CaloIsoVL_TrkIdVL_TrkIsoT_TriCentralPFNoPUJet30_v6(L,3) indx x y z rho chi2 ndf + 0 0.24 0.39 0.39 0.46 1.1e+02 1.1e+02 + 1 0.24 0.39 0.39 0.46 23 33 + 2 0.24 0.4 0.4 0.46 58 85 + 3 0.25 0.39 0.39 0.46 5.7 17 + 4 0.24 0.39 0.39 0.45 24 25 + 5 0.25 0.39 0.39 0.46 8.9 13 + 6 0.25 0.39 0.39 0.46 0.65 1 + 7 0.25 0.39 0.39 0.47 15 26 + 8 0.23 0.38 0.38 0.45 19 21 + 9 0.25 0.39 0.39 0.46 8.7 8.3 + 10 0.21 0.39 0.39 0.44 12 10 + 11 0.25 0.39 0.39 0.46 12 12 + 12 0.24 0.39 0.39 0.46 4.4 13 + 13 0.24 0.38 0.38 0.45 1.6 4.8 + 14 0.25 0.39 0.39 0.47 5.6 4.7 + 15 0.26 0.39 0.39 0.47 1.9 2.9 + 16 0.24 0.4 0.4 0.47 12 8.3 + 17 0.17 0.34 0.34 0.38 2.4 0.82 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002028 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 8th record. Run 1, Event 7002029, LumiSection 70021 at 19-Sep-2014 22:10:04.684 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002029 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002029 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltL1SeededRecoEcalCandidate::HLT + Type IDs: 81 + Filters: hltEG20CaloIdVLHEFilter hltEG26CaloId10Iso50HcalIsoLastFilter hltEG26HE10LastFilter hltEG26R9Id85LastFilter hltEG30CaloIdVLHEFilter hltEG30CaloIdVTHEFilterL1EG22 hltEG36CaloId10Iso50HcalIsoLastFilter hltEG36HE10LastFilter hltEG36R9Id85LastFilter hltEG40CaloIdLHEFilter hltEG48HEVTFilter hltEG53HEVTFilter hltEG60CaloIdLHEFilter hltEG70CaloIdXLHEFilter hltEG70HEFilter hltEle13WP90ClusterShapeFilter hltEle13WP90NoIsoHEFilter hltEle13WP90RhoEcalIsoFilter hltEle13WP90RhoHEFilter hltEle13WP90RhoHcalIsoFilter hltEle22WP90NoIsoHEFilter hltEle22WP90RhoClusterShapeFilter hltEle22WP90RhoEcalIsoFilter hltEle22WP90RhoHEFilter hltEle22WP90RhoHcalIsoFilter hltPhoton22R9Id90HE10Iso40EBOnlyTrackIsoLastFilter hltPhoton30HEFilter hltPhoton30R9Id90CaloIdHE10Iso40EBOnlyTrackIsoLastFilter hltPhoton36R9Id90HE10Iso40EBOnlyTrackIsoLastFilter hltPhoton50CaloIdVLHEFilter hltPhoton50R9Id90HE10Iso40EBOnlyTrackIsoLastFilter hltSingleEle13WP90RhoClusterShapeFilter hltSingleEle13WP90RhoEcalIsoFilter hltSingleEle13WP90RhoHEFilter hltSingleEle13WP90RhoHcalIsoFilter + Paths (10/9): HLT_Photon20_CaloIdVL_v5(L,3) HLT_Photon30_CaloIdVL_v15(L,3) HLT_Photon60_CaloIdL_HT300_v5(L,3) HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_v6(L,3) HLT_Photon30_v2(L,3) HLT_Photon30_R9Id90_CaloId_HE10_Iso40_EBOnly_v2(L,3) HLT_Photon30_R9Id90_CaloId_HE10_Iso40_EBOnly_Met25_HBHENoiseCleaned_v2(*,3) HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_v6(L,3) HLT_Photon50_CaloIdVL_v11(L,3) HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_v6(L,3) Collection: hltL1SeededRecoEcalCandidate::HLT + Type IDs: 81 + Filters: hltEG20CaloIdVLHEFilter hltEG30CaloIdVLHEFilter hltPhoton50CaloIdVLHEFilter + Paths (3/3): HLT_Photon20_CaloIdVL_v5(L,3) HLT_Photon30_CaloIdVL_v15(L,3) HLT_Photon50_CaloIdVL_v11(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 81 92 + Filters: hltDoubleEG48HEVTDoubleFilter hltDoubleEG53HEVTDoubleFilter hltEG10CaloId10Iso50TrackIsoLastFilterUnseeded hltEG10R9Id85LastFilterUnseeded hltEG18HE10DoubleLastFilterUnseeded hltEG22HE10DoubleLastFilterUnseeded hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional + Paths (0/0): Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 86 + Filters: hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltTripleL2Jets30eta3 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 86 + Filters: hltCentralJet65L1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltTripleL2Jets30eta3 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 86 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiJet30L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleCentralJet40L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadJet25HbbZbb hltTripleL2Jets30eta3 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiJet30L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltQuadJet25HbbZbb hltTripleL2Jets30eta3 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiJet30L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltQuadJet25HbbZbb hltTripleL2Jets30eta3 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiJet30L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltQuadJet25HbbZbb hltTripleL2Jets30eta3 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltQuadJet25HbbZbb + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltL1FastJetQuad18HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltL1FastJetQuad18HbbVBF + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (0/0): Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (0/0): Collection: hltPFHT400::HLT + Type IDs: 90 + Filters: hltPFHT400 + Paths (0/0): Collection: hltMet::HLT + Type IDs: 87 + Filters: hltMET15 + Paths (1/0): HLT_Photon30_R9Id90_CaloId_HE10_Iso40_EBOnly_Met25_HBHENoiseCleaned_v2(*,3) Collection: hltMetClean::HLT + Type IDs: 87 + Filters: hltMETClean25 + Paths (1/1): HLT_Photon30_R9Id90_CaloId_HE10_Iso40_EBOnly_Met25_HBHENoiseCleaned_v2(L,3) Collection: hltHITIPTCorrectorHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL3FilterHB + Paths (1/1): HLT_IsoTrackHB_v15(L,3) Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (1/0): HLT_IsoTrackHB_v15(*,3) Collection: hltIsolPixelTrackProdHB::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHB + Paths (1/0): HLT_IsoTrackHB_v15(*,3) Collection: hltIsolPixelTrackProdHE::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHE + Paths (0/0): Collection: hltL1extraParticles:Isolated:HLT + Type IDs: -83 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1IsoEG12erETM36 hltL1sL1SingleEG12 hltL1sL1SingleEG20ORL1SingleEG22 hltL1sL1SingleEG22 hltL1sL1SingleEG24 hltL1sL1SingleEG30 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1SingleIsoEG18erORIsoEG20erOREG22 hltL1sL1SingleIsoEG18erORL1SingleIsoEG20er hltL1sL1TripleEG7 + Paths (14/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Photon20_CaloIdVL_v5(*,3) HLT_L1SingleEG12_v6(L,3) HLT_Photon30_v2(*,3) HLT_Photon30_CaloIdVL_v15(*,3) HLT_Photon30_R9Id90_CaloId_HE10_Iso40_EBOnly_v2(*,3) HLT_Photon30_R9Id90_CaloId_HE10_Iso40_EBOnly_Met25_HBHENoiseCleaned_v2(*,3) HLT_Photon50_CaloIdVL_v11(*,3) HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_v6(*,3) HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_v6(*,3) HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_v6(*,3) HLT_Photon60_CaloIdL_HT300_v5(*,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:Isolated:HLT + Type IDs: -83 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1TripleEG7 + Paths (3/3): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1SingleEG12 hltL1sL1SingleEG20ORL1SingleEG22 hltL1sL1SingleEG22 hltL1sL1SingleEG24 hltL1sL1SingleEG30 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1SingleIsoEG18erORIsoEG20erOREG22 hltL1sL1TripleEG7 + Paths (14/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_Photon20_CaloIdVL_v5(*,3) HLT_L1SingleEG12_v6(L,3) HLT_Photon30_v2(*,3) HLT_Photon30_CaloIdVL_v15(*,3) HLT_Photon30_R9Id90_CaloId_HE10_Iso40_EBOnly_v2(*,3) HLT_Photon30_R9Id90_CaloId_HE10_Iso40_EBOnly_Met25_HBHENoiseCleaned_v2(*,3) HLT_Photon50_CaloIdVL_v11(*,3) HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_v6(*,3) HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_v6(*,3) HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_v6(*,3) HLT_Photon60_CaloIdL_HT300_v5(*,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (15/9): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (15/9): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_IsoTrackHB_v15(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (11/6): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (11/6): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleForJet16EtaOpp hltL1sL1SingleForJet16 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF + Paths (10/5): HLT_HcalNZS_v10(L,3) HLT_DoubleJet20_ForwardBackward_v4(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_IsoTrackHB_v15(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1DoubleForJet16EtaOpp hltL1sL1SingleForJet16 hltL1sL1SingleJet16 hltL1sL1SingleJet36 + Paths (9/5): HLT_HcalNZS_v10(L,3) HLT_DoubleJet20_ForwardBackward_v4(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1DoubleForJet16EtaOpp hltL1sL1SingleForJet16 hltL1sL1SingleJet16 hltL1sL1SingleJet36 + Paths (9/5): HLT_HcalNZS_v10(L,3) HLT_DoubleJet20_ForwardBackward_v4(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1DoubleForJet16EtaOpp hltL1sL1SingleForJet16 hltL1sL1SingleJet16 + Paths (6/4): HLT_HcalNZS_v10(L,3) HLT_DoubleJet20_ForwardBackward_v4(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (11/6): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (7/4): HLT_HcalNZS_v10(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1EG8DoubleJet20Central hltL1sL1SingleJet16 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (5/2): HLT_HcalNZS_v10(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1EG8DoubleJet20Central hltL1sL1SingleJet16 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF + Paths (4/2): HLT_HcalNZS_v10(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -87 + Filters: hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1ETM30 hltL1sL1ETM36ORETM40 hltL1sL1ETM36ORETM40ORETM50 hltL1sL1ETM36or40 hltL1sL1ETM40 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1IsoEG12erETM36 + Paths (2/2): HLT_L1ETM30_v2(L,3) HLT_L1ETM40_v2(L,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (2/2): HLT_PixelTracks_Multiplicity80_v13(L,3) HLT_PixelTracks_Multiplicity70_v4(L,3) Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sAlCaEcalPi0Eta hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (4/4): DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve40 hltDiPFJetAve80 + Paths (2/2): HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve40 hltDiPFJetAve80 + Paths (2/2): HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackPt20Isolation::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20LooseIso + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackPt20Isolation::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20LooseIso + Paths (1/0): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(*,3) Collection: hltSelectedPFTausTrackPt20IsolationProng2::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20LooseIsoProng2 + Paths (1/1): HLT_LooseIsoPFTau35_Trk20_Prong1_v11(L,3) indx x y z rho chi2 ndf + 0 0.25 0.39 0.39 0.46 55 79 + 1 0.24 0.39 0.39 0.46 1.3e+02 1.5e+02 + 2 0.24 0.39 0.39 0.46 1.4e+02 1.6e+02 + 3 0.24 0.39 0.39 0.46 74 1.1e+02 + 4 0.24 0.39 0.39 0.46 22 36 + 5 0.24 0.4 0.4 0.46 39 41 + 6 0.24 0.39 0.39 0.46 1e+02 1.4e+02 + 7 0.24 0.39 0.39 0.46 62 79 + 8 0.24 0.4 0.4 0.47 65 70 + 9 0.25 0.4 0.4 0.47 70 59 + 10 0.24 0.39 0.39 0.46 22 20 + 11 0.24 0.39 0.39 0.45 33 29 + 12 0.24 0.39 0.39 0.46 26 23 + 13 0.25 0.39 0.39 0.47 34 44 + 14 0.25 0.4 0.4 0.47 21 13 + 15 0.25 0.39 0.39 0.46 19 28 + 16 0.25 0.4 0.4 0.47 23 30 + 17 0.23 0.4 0.4 0.46 19 30 + 18 0.25 0.42 0.42 0.49 9.4 10 + 19 0.26 0.39 0.39 0.47 15 14 + 20 0.27 0.41 0.41 0.49 1.1 4.9 + 21 0.19 0.37 0.37 0.42 6 6.4 + 22 0.19 0.44 0.44 0.48 1.7 0.87 + 23 0.3 0.37 0.37 0.47 5 4.7 + 24 0.21 0.39 0.39 0.45 5 4.6 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002029 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 9th record. Run 1, Event 7002048, LumiSection 70021 at 19-Sep-2014 22:10:04.694 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002048 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002048 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltL1SeededRecoEcalCandidate::HLT + Type IDs: 81 + Filters: hltEG26HE10LastFilter hltEG36HE10LastFilter hltPhoton30HEFilter + Paths (1/1): HLT_Photon30_v2(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 81 92 + Filters: hltEG18HE10DoubleLastFilterUnseeded hltEG22HE10DoubleLastFilterUnseeded hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltL2MuonCandidates::HLT + Type IDs: 83 + Filters: hltDimuon0or33L2PreFiltered0 hltDimuon30L2PreFiltered0 hltDimuon33L2PreFiltered0 hltDimuonL2PreFiltered0 hltDoubleMu4L2PreFiltered hltIgnoredL1SingleMuOpenL2DiMuFiltered0 hltL1DoubleMu10MuOpenORDoubleMu103p5L2DiMuFiltered0 hltL1DoubleMu3p5EG5L2DiMuFiltered3p5 hltL1DoubleMu5EG5L2DiMuFiltered5 hltL1HTT150singleMuL2PreFiltered0 hltL1HTT150singleMuL2PreFiltered10 hltL1Mu0EG5L2MuFiltered0 hltL1Mu0HTT100L2Filtered0 hltL1Mu0HTT100ORMu4HTT125L2Filtered0 hltL1Mu12EG7L2MuFiltered0 hltL1Mu12EG7ORL1MuOpenEG12L2MuFiltered0 hltL1Mu3p5EG12L2Filtered12 hltL1Mu4HTT125L2Filtered0 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L2Filtered5 hltL2L1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL2MuFiltered10Eta2p1 hltL2Mu5DoubleEG5L2Filtered5 hltL2fL1DoubleMu10MuOpenOR3p5L1f0L2Filtered10 hltL2fL1sDoubleMu10MuOpenOR3p5L1f0L2Filtered10 hltL2fL1sMu12Eta2p1L1f0L2Filtered12Q hltL2fL1sMu12L2Filtered12 hltL2fL1sMu14Eta2p1L1f0L2Filtered14Q hltL2fL1sMu14erORMu16erL1f0L2Filtered14Q hltL2fL1sMu3L2Filtered3 hltL2fL1sMu7Eta2p1L1f0L2Filtered7Q hltL2fL1sMu7L1fEta2p1L2FilteredEta2p1Filtered7 hltL2fL1sMu7L2Filtered7 hltL2fL1sSingleMu7Eta2p1L1f0L2Filtered7Q hltL2pfL1DoubleMu10MuOpenOR3p5L1f0L2PreFiltered0 hltMu15TkMu5DCAL2Filtered10 hltMu5L2Mu3L2PreFiltered0 hltMu5TrackJpsiL2Filtered3 hltSingleMuOpenCandidateL2Filtered0 hltSingleMuOpenCandidateL2Filtered3 + Paths (21/0): HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_PFNoPUHT400_Mu5_PFMET45_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET50_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET45_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET50_v5(*,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu15_eta2p1_v6(*,3) HLT_Mu12_v19(*,3) DST_Mu5_HT250_v5(*,3) Collection: hltL3MuonCandidates::HLT + Type IDs: 83 + Filters: hltDoubleDisplacedMu4L3PreFiltered hltL1DoubleMu3p5EG5L3DiMuFiltered5 hltL1DoubleMu5EG5L3DiMuFiltered8 hltL1HTT150singleMuL3PreFiltered15 hltL1HTT150singleMuL3PreFiltered5 hltL1Mu0EG5L3MuFiltered7 hltL1Mu0HTT100L3Filtered5 hltL1Mu0HTT100ORMu4HTT125L3Filtered8 hltL1Mu10Eta2p1Jet20Jet12CentralCorrOrMu10erJetC32OrMu12erOrMu14erL3Mufiltered15Eta2p1 hltL1Mu12EG7ORL1MuOpenEG12L3MuFiltered14 hltL1Mu4HTT125L3Filtered5 hltL1sL1Mu3p5EG12ORL1MuOpenEG12L3Filtered8 hltL3L1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL3Mufiltered12Eta2p1 hltL3Mu8DoubleJetC20L3Filtered8 hltL3fL1sMu12Eta2p1L1f0L2f12QL3Filtered15Q hltL3fL1sMu3L3Filtered5 hltL3fL1sMu3L3Filtered8 hltL3fL1sMu7Eta2p1L1f0L2f7QL3Filtered8Q hltL3fL1sMu7L1fEta2p1L2fEta2p1f7L3FilteredEta2p1Filtered15 hltL3fL1sMu7L3Filtered12 hltL3fL1sSingleMu7Eta2p1L1f0L2f7QL3Filtered8Q hltL3pfL1DoubleMu10MuOpenOR3p5L1f0L2pf0L3PreFiltered8 hltMu15TkMu5DCAL3Filtered15 hltMu15TkMu5TrackMassFilteredOnia hltMu5DoubleEG5L3Filtered8 hltMu5L2Mu3L3Filtered5 hltMu5TrackJpsiL3Filtered3 hltOverlapFilterMu8LooseIsoPFTau20 hltSingleMuOpenCandidateL3Filtered12 hltSingleMuOpenCandidateL3Filtered5 hltTauTo2MuL3Filtered + Paths (24/17): HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_PFNoPUHT350_Mu15_PFMET45_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET50_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET45_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET50_v5(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(L,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(L,3) HLT_Mu15_eta2p1_DiCentral_20_v2(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(L,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(L,3) HLT_Mu12_eta2p1_DiCentral_20_v9(L,3) HLT_Mu8_DiJet30_v8(L,3) HLT_Mu8_TriJet30_v8(L,3) HLT_Mu8_QuadJet30_v8(L,3) HLT_Mu15_eta2p1_L1ETM20_v6(L,3) HLT_Mu5_v21(L,3) HLT_Mu8_v19(L,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(L,3) HLT_Mu15_eta2p1_v6(L,3) HLT_Mu12_v19(L,3) DST_Mu5_HT250_v5(L,3) Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltMuTrackCtfTrackCandsOnia::HLT + Type IDs: 91 + Filters: hltMu15TkMu5TrackMassFilteredOnia + Paths (0/0): Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (2/0): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) Collection: hltBLifetimeL25Jet20HbbL1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL25FilterJet20HbbL1FastJet hltDiBLifetime3D1stTrkL25FilterJet20HbbL1FastJet + Paths (2/0): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional + Paths (2/0): HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional + Paths (2/0): HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (2/0): HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (2/0): HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJet40CentralL1FastJet hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDiJet75HbbZbb hltDijet40L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet hltTripleL2Jets30eta3 + Paths (23/12): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) HLT_QuadJet80_v6(L,3) HLT_QuadJet90_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet30L1FastJet hltDijet40L1FastJet hltDoubleCentralJet65L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSixCenJet20L1FastJet hltTripleL2Jets30eta3 + Paths (13/12): HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) HLT_QuadJet80_v6(L,3) HLT_QuadJet90_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJet40CentralL1FastJet hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDiJet75HbbZbb hltDijet40L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet hltTripleL2Jets30eta3 + Paths (23/12): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) HLT_QuadJet80_v6(L,3) HLT_QuadJet90_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJet40CentralL1FastJet hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDiJet75HbbZbb hltDijet40L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet hltTripleL2Jets30eta3 + Paths (23/12): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) HLT_QuadJet80_v6(L,3) HLT_QuadJet90_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJet40CentralL1FastJet hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDijet40L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet hltTripleL2Jets30eta3 + Paths (21/10): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_QuadJet70_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJet40CentralL1FastJet hltBJetHbb hltCentralJet50 hltCentralJet65L1FastJet hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDijet40L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltSingleBJet60Eta1p7L1FastJet hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet hltTripleL2Jets30eta3 + Paths (20/9): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_RsqMR40_Rsq0p04_v6(L,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_SixJet50_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_QuadJet50_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJet40CentralL1FastJet hltBJetHbb hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDijet40L1FastJet hltDoubleBJet40Eta2p6L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadJet25HbbZbb hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet hltTripleL2Jets30eta3 + Paths (16/6): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_SixJet35_v6(L,3) HLT_SixJet45_v6(L,3) HLT_QuadJet45_v1(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltDiJet30L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltQuadJet25HbbZbb hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet hltTripleL2Jets30eta3 + Paths (12/3): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_EightJet30_eta3p0_v5(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltQuadJet25HbbZbb hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet + Paths (11/2): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltQuadJet25HbbZbb hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet + Paths (11/2): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 86 85 + Filters: hltBJetHbb hltDiBJet20CentralL1FastJet hltDiCaloJet20NoEtaCut hltDiCentralJet15 hltDiCentralJet20L1FastJetCorrected hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltSixCenJet20L1FastJet hltTriBJet20CentralL1FastJet + Paths (11/2): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(L,3) HLT_QuadJet60_DiJet20_v6(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCentralJet15 hltL1FastJetQuad18HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCentralJet15 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCentralJet15 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCentralJet15 + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCentralJet15 + Paths (0/0): Collection: hltGetJetsfromBLifetime3D1stTrkL25FilterJet20Hbb::HLT + Type IDs: 86 + Filters: hltBLifetime3D1stTrkL3FilterJet20HbbL1FastJet + Paths (2/2): HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(L,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(L,3) Collection: hltGetJetsfromDiBLifetime3D1stTrkL25FilterJet20Hbb::HLT + Type IDs: 86 + Filters: hltDiBLifetime3D1stTrkL3FilterJet20HbbL1FastJet + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltFilterL2EtCutSingleIsoPFTau35Trk20 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltFilterL2EtCutSingleIsoPFTau35Trk20 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltFilterL2EtCutSingleIsoPFTau35Trk20 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (0/0): Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV + Paths (0/0): Collection: hltPFHT350MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT350MET100orMHT150 + Paths (1/1): HLT_PFNoPUHT350_PFMET100_v5(L,3) Collection: hltPFHT350MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT350MET100orMHT150 + Paths (1/1): HLT_PFNoPUHT350_PFMET100_v5(L,3) Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (1/1): HLT_PFNoPUHT350_v5(L,3) Collection: hltPFHT350PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT350PFMET45 + Paths (1/1): HLT_PFNoPUHT350_Mu15_PFMET45_v5(L,3) Collection: hltPFHT350PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT350PFMET50 + Paths (1/1): HLT_PFNoPUHT350_Mu15_PFMET50_v5(L,3) Collection: hltPFHT400MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT400MET100orMHT150 + Paths (1/1): HLT_PFNoPUHT400_PFMET100_v5(L,3) Collection: hltPFHT400MET100orMHT150::HLT + Type IDs: 90 + Filters: hltPFHT400MET100orMHT150 + Paths (1/1): HLT_PFNoPUHT400_PFMET100_v5(L,3) Collection: hltPFHT400PFMET45::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET45 + Paths (1/1): HLT_PFNoPUHT400_Mu5_PFMET45_v5(L,3) Collection: hltPFHT400PFMET50::HLT + Type IDs: 90 + Filters: hltPFHT400PFMET50 + Paths (1/1): HLT_PFNoPUHT400_Mu5_PFMET50_v5(L,3) Collection: hltPFHT650NoPU::HLT + Type IDs: 90 + Filters: hltPFHT650NoPU + Paths (1/1): HLT_PFNoPUHT650_v5(L,3) Collection: hltPFHT650TriCentralJet40NoPU::HLT + Type IDs: 90 + Filters: hltPFHT650TriCentralJet40NoPU + Paths (1/1): HLT_PFNoPUHT650_DiCentralPFNoPUJet80_CenPFNoPUJet40_v5(L,3) Collection: hltPFHT700NoPU::HLT + Type IDs: 90 + Filters: hltPFHT700NoPU + Paths (1/1): HLT_PFNoPUHT700_v5(L,3) Collection: hltPFHT750NoPU::HLT + Type IDs: 90 + Filters: hltPFHT750NoPU + Paths (1/1): HLT_PFNoPUHT750_v5(L,3) Collection: hltPFMET80MuORNoMu::HLT + Type IDs: 90 + Filters: hltPFMET80MuORNoMu + Paths (1/1): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(L,3) Collection: hltPFMET80MuORNoMu::HLT + Type IDs: 90 + Filters: hltPFMET80MuORNoMu + Paths (1/1): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(L,3) Collection: hltPFMETProducer::HLT + Type IDs: 90 + Filters: hltPFMET80Filter + Paths (1/1): HLT_DiCentralPFJet30_PFMET80_v7(L,3) Collection: hltPFMETnoMu105::HLT + Type IDs: 90 + Filters: hltPFMETnoMu105 + Paths (1/1): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(L,3) Collection: hltMet::HLT + Type IDs: 87 + Filters: hltMET50 hltMET65 hltMET70 hltMET75 hltMET80 + Paths (5/2): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_MET80_v5(L,3) HLT_MET80_Parked_v5(L,3) Collection: hltMetClean::HLT + Type IDs: 87 + Filters: hltMETClean25 + Paths (0/0): Collection: hltIsolPixelTrackProdHE::HLT + Type IDs: 91 + Filters: hltIsolPixelTrackL2FilterHE + Paths (0/0): Collection: hltL1extraParticles:Isolated:HLT + Type IDs: -83 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1DoubleMu3p5EG5 hltL1sL1DoubleMu5EG5 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1IsoEG12erETM36 hltL1sL1Mu0EG5 hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1SingleEG12 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1TripleEG7 + Paths (4/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_L1SingleEG12_v6(L,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1DoubleMu3p5EG5 hltL1sL1DoubleMu5EG5 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1Mu0EG5 hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1SingleEG12 hltL1sL1SingleEG20ORL1SingleEG22 hltL1sL1SingleEG22 hltL1sL1SingleEG24 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1SingleIsoEG18erORIsoEG20erOREG22 hltL1sL1TripleEG7 + Paths (5/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_L1SingleEG12_v6(L,3) HLT_Photon30_v2(*,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG137 hltL1sL1DoubleEG137ORL1DoubleEG155 hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1DoubleMu3p5EG5 hltL1sL1DoubleMu5EG5 hltL1sL1EG12EG7EG5 hltL1sL1EG8DoubleJet20Central hltL1sL1Mu0EG5 hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1SingleEG5 hltL1sL1SingleEG7 hltL1sL1TripleEG7 + Paths (3/3): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles::HLT + Type IDs: -81 + Filters: hltDimuon0or33L1Filtered0 hltDimuon30L1Filtered0 hltDimuon33L1Filtered0 hltDimuonL1Filtered0 hltL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14erL1MuFiltered0Eta2p1 hltL1MuOpenL1Filtered0 hltL1sAlCaEcalPi0Eta hltL1sAlCaRPC hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleMu0 hltL1sL1DoubleMu0erHighQ hltL1sL1DoubleMu0erHighQORDoubleMu3er0erHighQWdEta22 hltL1sL1DoubleMu0erOR3erHighQ hltL1sL1DoubleMu0or33HighQ hltL1sL1DoubleMu103p5 hltL1sL1DoubleMu10Mu3p5 hltL1sL1DoubleMu10MuOpenORDoubleMu103p5 hltL1sL1DoubleMu30HighQ hltL1sL1DoubleMu33HighQ hltL1sL1DoubleMu3p5EG5 hltL1sL1DoubleMu5EG5 hltL1sL1Mu0EG5 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu12EG7 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu4HTT125 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1Mu7erETM26 hltL1sL1Mu8DoubleJetC20 hltL1sL1SingleMu12 hltL1sL1SingleMu12erORSingleMu14er hltL1sL1SingleMu16er hltL1sL1SingleMu3 hltL1sL1SingleMu7 hltL1sL1SingleMuOpen hltL1sL1SingleMuOpenCandidate hltL1sMu12Eta2p1ETM20 hltL1sMu14Eta2p1 hltL1sMu14erORMu16er hltL1sMu16 hltL1sMu16Eta2p1 hltMu5L2Mu3L1Filtered0 hltMu5TrackJpsiL1Filtered0 hltRPCMuonNormaL1Filtered0 + Paths (25/6): HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_L1SingleMuOpen_v7(L,3) HLT_L1SingleMuOpen_AntiBPTX_v7(L,3) AlCa_RPCMuonNormalisation_v9(L,3) HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_L1SingleMu12_v2(L,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_Mu12_v19(*,3) HLT_Mu15_eta2p1_v6(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) Collection: hltL1extraParticles::HLT + Type IDs: -81 + Filters: hltDimuon0or33L1Filtered0 hltDimuon30L1Filtered0 hltDimuon33L1Filtered0 hltDimuonL1Filtered0 hltL1MuOpenL1Filtered0 hltL1sAlCaEcalPi0Eta hltL1sAlCaRPC hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleMu0 hltL1sL1DoubleMu0erHighQ hltL1sL1DoubleMu0erHighQORDoubleMu3er0erHighQWdEta22 hltL1sL1DoubleMu0erOR3erHighQ hltL1sL1DoubleMu0or33HighQ hltL1sL1DoubleMu103p5 hltL1sL1DoubleMu10Mu3p5 hltL1sL1DoubleMu10MuOpenORDoubleMu103p5 hltL1sL1DoubleMu30HighQ hltL1sL1DoubleMu33HighQ hltL1sL1DoubleMu3p5EG5 hltL1sL1DoubleMu5EG5 hltL1sL1Mu0EG5 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu12EG7ORL1MuOpenEG12 hltL1sL1Mu3p5EG12 hltL1sL1Mu3p5EG12ORL1MuOpenEG12 hltL1sL1Mu4HTT125 hltL1sL1Mu5DoubleEG5ORMu5DoubleEG6 hltL1sL1Mu7erETM26 hltL1sL1Mu8DoubleJetC20 hltL1sL1SingleMu3 hltL1sL1SingleMu7 hltL1sL1SingleMuOpen hltL1sL1SingleMuOpenCandidate hltMu5L2Mu3L1Filtered0 hltMu5TrackJpsiL1Filtered0 hltRPCMuonNormaL1Filtered0 + Paths (14/5): HLT_L1SingleMuOpen_v7(L,3) HLT_L1SingleMuOpen_AntiBPTX_v7(L,3) AlCa_RPCMuonNormalisation_v9(L,3) HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_DoubleDisplacedMu4_DiPFJet40Neutral_v9(*,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_Mu5_v21(*,3) HLT_Mu8_v19(*,3) HLT_Mu12_v19(*,3) HLT_Mu15_eta2p1_v6(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (39/14): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT400_AlphaT0p51_v19(L,3) HLT_HT450_AlphaT0p51_v14(L,3) HLT_HT450_v7(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (39/14): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT400_AlphaT0p51_v19(L,3) HLT_HT450_AlphaT0p51_v14(L,3) HLT_HT450_v7(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (39/14): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT400_AlphaT0p51_v19(L,3) HLT_HT450_AlphaT0p51_v14(L,3) HLT_HT450_v7(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1Mu10erJetC20JetC12Corr1OrL1Mu10erJetC32OrMu10erJetC32JetC12Corr1OrMu12erOrMu14er hltL1sL1Mu8DoubleJetC20 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (39/14): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_HT200_v6(L,3) HLT_RsqMR40_Rsq0p04_v6(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT400_AlphaT0p51_v19(L,3) HLT_HT450_AlphaT0p51_v14(L,3) HLT_HT450_v7(L,3) HLT_Mu12_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v8(*,3) HLT_Mu15_eta2p1_L1Mu10erJetC12WdEtaPhi1DiJetsC_v4(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu12_eta2p1_DiCentral_40_20_v9(*,3) HLT_Mu12_eta2p1_DiCentral_20_v9(*,3) HLT_Mu15_eta2p1_DiCentral_40_20_v2(*,3) HLT_Mu15_eta2p1_DiCentral_20_v2(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_BTagIP3D1stTrack_v9(*,3) HLT_Mu15_eta2p1_TriCentral_40_20_20_v9(*,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) HLT_DiPFJetAve140_v11(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1EG8DoubleJet20Central hltL1sL1Mu8DoubleJetC20 hltL1sL1SingleJet16 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF + Paths (7/2): HLT_HcalNZS_v10(L,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1EG8DoubleJet20Central hltL1sL1Mu8DoubleJetC20 hltL1sL1SingleJet16 + Paths (7/2): HLT_HcalNZS_v10(L,3) HLT_Mu8_DiJet30_v8(*,3) HLT_Mu8_TriJet30_v8(*,3) HLT_Mu8_QuadJet30_v8(*,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -87 + Filters: hltL1sL1DoubleJetC36ETM30ORL1DoubleJetC44ETM30 hltL1sL1ETM30 hltL1sL1ETM36ORETM40 hltL1sL1ETM36ORETM40ORETM50 hltL1sL1ETM36or40 hltL1sL1ETM40 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1IsoEG12erETM36 hltL1sL1Mu7erETM26 hltL1sMu12Eta2p1ETM20 + Paths (9/2): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) HLT_L1ETM30_v2(L,3) HLT_DiCentralPFJet30_PFMET80_v7(*,3) HLT_MET80_v5(*,3) HLT_MET80_Parked_v5(*,3) HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_L1ETM40_v2(L,3) HLT_Mu8_eta2p1_LooseIsoPFTau20_L1ETM26_v2(*,3) HLT_Mu15_eta2p1_L1ETM20_v6(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (0/0): Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sAlCaEcalPi0Eta hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1Mu0HTT100 hltL1sL1Mu0HTT100ORL1Mu4HTT125 hltL1sL1Mu4HTT125 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (35/12): HLT_PFNoPUHT350_v5(*,3) HLT_PFNoPUHT650_v5(*,3) HLT_PFNoPUHT650_DiCentralPFNoPUJet80_CenPFNoPUJet40_v5(*,3) HLT_PFNoPUHT700_v5(*,3) HLT_PFNoPUHT750_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET45_v5(*,3) HLT_PFNoPUHT350_Mu15_PFMET50_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET45_v5(*,3) HLT_PFNoPUHT400_Mu5_PFMET50_v5(*,3) HLT_PFNoPUHT350_PFMET100_v5(*,3) HLT_PFNoPUHT400_PFMET100_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) DST_Mu5_HT250_v5(*,3) HLT_QuadJet70_v6(*,3) HLT_QuadJet80_v6(*,3) HLT_QuadJet90_v6(*,3) HLT_SixJet35_v6(*,3) HLT_SixJet45_v6(*,3) HLT_SixJet50_v6(*,3) HLT_EightJet30_eta3p0_v5(*,3) HLT_HT500_v7(L,3) HLT_HT550_v7(L,3) HLT_HT650_v7(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_HT400_v7(L,3) HLT_HT400_AlphaT0p51_v19(L,3) HLT_HT450_AlphaT0p51_v14(L,3) HLT_HT450_v7(L,3) HLT_DiJet80_DiJet60_DiJet20_v6(*,3) HLT_QuadJet45_v1(*,3) HLT_QuadJet50_v5(*,3) HLT_QuadJet60_DiJet20_v6(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet80 hltDiPFJetAve140 hltDiPFJetAve40 hltDiPFJetAve80 hltPFNHEF95Filter + Paths (4/3): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) HLT_DiPFJetAve140_v11(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJetAve140 hltDiPFJetAve40 hltDiPFJetAve80 + Paths (3/3): HLT_DiPFJetAve140_v11(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet80 + Paths (1/0): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet80 + Paths (1/0): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltCentralPFJet80 + Paths (1/0): HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v5(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) Collection: hltAK5PFJetL1FastL2L3CorrectedNoPU::HLT + Type IDs: 85 + Filters: hltDiCentralPFJet50NoPU + Paths (1/0): HLT_DiCentralPFNoPUJet50_PFMETORPFMETNoMu80_v5(*,3) indx x y z rho chi2 ndf + 0 0.24 0.39 0.39 0.46 1.7e+02 1.7e+02 + 1 0.25 0.4 0.4 0.47 50 76 + 2 0.25 0.39 0.39 0.46 30 47 + 3 0.24 0.4 0.4 0.46 59 70 + 4 0.24 0.4 0.4 0.47 58 62 + 5 0.24 0.4 0.4 0.46 61 68 + 6 0.24 0.4 0.4 0.47 35 38 + 7 0.24 0.39 0.39 0.46 21 33 + 8 0.24 0.39 0.39 0.46 18 32 + 9 0.24 0.39 0.39 0.46 14 16 + 10 0.25 0.39 0.39 0.46 16 20 + 11 0.24 0.41 0.41 0.48 15 16 + 12 0.25 0.38 0.38 0.46 2.4 13 + 13 0.24 0.39 0.39 0.45 26 27 + 14 0.27 0.4 0.4 0.48 22 23 + 15 0.26 0.41 0.41 0.48 9.5 6.3 + 16 0.24 0.41 0.41 0.48 0.71 2.9 + 17 0.23 0.39 0.39 0.45 0.53 0.93 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002048 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +Begin processing the 10th record. Run 1, Event 7002051, LumiSection 70021 at 19-Sep-2014 22:10:04.720 CEST +%MSG-e EventBlock: EventBlock:eventBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002051 +Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG +%MSG-e TriggerBlock: TriggerBlock:triggerBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002051 +Error >> Failed to get L1GlobalTriggerReadoutRecord for label: InputTag: label = gtDigis, instance = +%MSG + Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltRecoEcalSuperClusterActivityCandidate::HLT + Type IDs: 92 + Filters: hltEgammaSelectEcalSuperClustersActivityFilterSC7 + Paths (1/1): HLT_Activity_Ecal_SC7_v14(L,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltExclDiJet35HFOR hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrected::HLT + Type IDs: 85 + Filters: hltSingleJet50 + Paths (2/0): HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional hltSingleJet140Regional + Paths (1/0): HLT_PFJet140_v10(*,3) Collection: hltCaloJetCorrectedRegional::HLT + Type IDs: 85 + Filters: hltSingleJet100Regional + Paths (1/0): HLT_PFJet140_v10(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 86 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltTripleL2Jets30eta3 + Paths (3/0): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 86 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltQuadJet90L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltTripleL2Jets30eta3 + Paths (3/0): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 86 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDiCenJet80L1FastJet hltDiJet75HbbZbb hltDoubleBJet40Eta2p6L1FastJet hltDoubleBJet53Eta1p7L1FastJet hltDoubleBJet70Eta1p7L1FastJet hltDoubleBJet80Eta2p6L1FastJet hltDoubleCentralJet65L1FastJet hltDoubleL2Jets30eta2p1 hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltExaJet45L1FastJet hltExaJet50L1FastJet hltL1FastJetDouble44HbbVBF hltL1FastJetDouble50HbbVBF hltL1FastJetDouble55HbbVBF hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetSingle64HbbVBF hltL1FastJetSingle66HbbVBF hltL1FastJetSingle75HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadCenJet45L1FastJet hltQuadCenJet50L1FastJet hltQuadCenJet60L1FastJet hltQuadJet25HbbZbb hltQuadJet70L1FastJet hltQuadJet80L1FastJet hltSingleBJet60Eta1p7L1FastJet hltSingleBJet80Eta1p7L1FastJet hltTripleL2Jets30eta3 + Paths (3/0): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 86 + Filters: hltDiCaloJet20NoEtaCut hltDiCaloJet30NoEtaCut hltDiCaloJet35NoEtaCut hltDoubleBJet40Eta2p6L1FastJet hltEightJet30eta3p0L1FastJet hltEightJet35eta3p0L1FastJet hltExaJet35L1FastJet hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltL1FastJetTriple30HbbVBF hltL1FastJetTriple35HbbVBF hltL1FastJetTriple38HbbVBF hltQuadJet25HbbZbb hltTripleL2Jets30eta3 + Paths (3/0): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF hltL1FastJetTriple24HbbVBF hltQuadJet25HbbZbb + Paths (3/0): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF hltL1FastJetQuad22HbbVBF + Paths (0/0): Collection: hltCaloJetL1FastJetCorrected::HLT + Type IDs: 85 + Filters: hltDiCaloJet20NoEtaCut hltL1FastJetQuad18HbbVBF hltL1FastJetQuad20HbbVBF + Paths (0/0): Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TauJets::HLT + Type IDs: 84 + Filters: hltDoubleL2Tau30eta2p1 hltDoubleL2Tau35eta2p1 hltFilterL2EtCutSingleIsoPFTau35Trk20 hltL2Tau25eta2p1 + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TauJetsIso::HLT + Type IDs: 84 + Filters: hltDoubleL2IsoTau30eta2p1 hltDoubleL2IsoTau35eta2p1 + Paths (1/1): HLT_DoubleIsoL2Tau30_eta2p1_v1(L,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltL2TausForPixelIsolation::HLT + Type IDs: 84 + Filters: hltL2DiTauIsoFilter + Paths (1/0): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltDiJetBLifetimeL3FilterHbbZbbCSV hltSingleJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV05 + Paths (3/0): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltBLifetimeL25FilterbbPhi1B1stTrackL1FastJetFastPV hltDiJetBLifetimeL3FilterHbbZbbCSV hltSingleJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV05 + Paths (3/0): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) Collection: hltSelectorJets20L1FastJet::HLT + Type IDs: 86 + Filters: hltDiJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV hltTriJetBLifetimeL3FilterHbbZbbCSV05 + Paths (3/0): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) Collection: hltPFHT350NoPU::HLT + Type IDs: 90 + Filters: hltPFHT350NoPU + Paths (1/1): HLT_PFNoPUHT350_v5(L,3) Collection: hltL1extraParticles:NonIsolated:HLT + Type IDs: -82 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sHcalPhiSym hltL1sL1DoubleEG5 hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1EG8DoubleJet20Central hltL1sL1SingleEG12 hltL1sL1SingleEG5 hltL1sL1SingleEG7 + Paths (4/4): HLT_HcalNZS_v10(L,3) HLT_HcalPhiSym_v11(L,3) HLT_L1SingleEG12_v6(L,3) HLT_L1SingleEG5_v6(L,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet128 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (19/10): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (19/10): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) Collection: hltL1extraParticles:Central:HLT + Type IDs: -84 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (10/6): HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1SingleForJet16 hltL1sL1SingleJet16 + Paths (5/3): HLT_HcalNZS_v10(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1SingleForJet16 hltL1sL1SingleJet16 + Paths (5/3): HLT_HcalNZS_v10(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:Forward:HLT + Type IDs: -85 + Filters: hltL1sHcalNZS hltL1sL1SingleForJet16 hltL1sL1SingleJet16 + Paths (5/3): HLT_HcalNZS_v10(L,3) HLT_SingleForJet25_v4(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sDoubleTauJet44erorDoubleJetC64 hltL1sHcalNZS hltL1sL1DoubleJet36Central hltL1sL1DoubleJetC44Eta1p74WdEta4 hltL1sL1DoubleJetC56Eta1p74WdEta4 hltL1sL1DoubleJetC56orL1DoubleJetC64 hltL1sL1DoubleJetC64ORDoubleJetC56ORDoubleJetC52 hltL1sL1EG8DoubleJet20Central hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 hltL1sL1SingleJet16 hltL1sL1SingleJet36 hltL1sL1SingleJet68 hltL1sL1SingleJet92 hltL1sL1TripleJet644424VBFORTripleJet644828VBFORTripleJet684832VBF hltL1sL1TripleJetC522828 + Paths (19/10): HLT_DoubleIsoL2Tau30_eta2p1_v1(*,3) HLT_HcalNZS_v10(L,3) HLT_L1DoubleJet36Central_v7(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(*,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(*,3) HLT_HT200_v6(L,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) HLT_L1SingleJet36_v7(L,3) HLT_PFJet80_v10(*,3) HLT_DiPFJetAve80_v11(*,3) HLT_PFJet140_v10(*,3) Collection: hltL1extraParticles:Tau:HLT + Type IDs: -86 + Filters: hltL1sAlCaEcalPi0Eta hltL1sHcalNZS hltL1sL1EG8DoubleJet20Central hltL1sL1SingleJet16 + Paths (4/2): HLT_HcalNZS_v10(L,3) HLT_L1SingleJet16_v7(L,3) HLT_PFJet40_v9(*,3) HLT_DiPFJetAve40_v10(*,3) Collection: hltL1extraParticles:MET:HLT + Type IDs: -88 + Filters: hltL1sETT140 hltL1sETT80 + Paths (0/0): Collection: hltL1extraParticles:MHT:HLT + Type IDs: -89 + Filters: hltL1sAlCaEcalPi0Eta hltL1sL1DoubleEG6HTT100ORHTT125 hltL1sL1HTT150OrHTT175 hltL1sL1HTT150OrHTT175OrDoubleJetC56OrSingleJet128OrQuadJetC32OrQuadJetC36OrQuadJetC40 hltL1sL1HTT150OrHTT175OrHTT200 hltL1sL1HTT150OrHTT175OrHTT200OrDoubleJetC56OrSingleJet128 hltL1sL1HTT200OrHTT175OrHTT150OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40 hltL1sL1HTT200OrL1HTT175OrETM40OrETM50 hltL1sL1QuadJetC32ORL1QuadJetC36ORQuadJetC40ORL1HTT125ORL1HTT150ORL1HTT175ORL1DoubleJetC52ORL1DoubleJetC56ORL1DoubleJetC64 + Paths (6/5): HLT_PFNoPUHT350_v5(*,3) DST_HT250_v5(L,3) DST_L1HTT_Or_L1MultiJet_v4(L,3) HLT_HT250_v7(L,3) HLT_HT300_v7(L,3) HLT_HT350_v7(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJet80HbbZbb hltDiPFJetAve40 hltDiPFJetAve80 hltQuadPFJet30HbbZbb + Paths (5/5): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltDiPFJet80HbbZbb hltDiPFJetAve40 hltDiPFJetAve80 hltQuadPFJet30HbbZbb + Paths (5/5): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) HLT_DiPFJetAve40_v10(L,3) HLT_DiPFJetAve80_v11(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltQuadPFJet30HbbZbb + Paths (3/3): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltQuadPFJet30HbbZbb + Paths (3/3): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltQuadPFJet30HbbZbb + Paths (3/3): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) Collection: hltAK5PFJetL1FastL2L3Corrected::HLT + Type IDs: 85 + Filters: hltQuadPFJet30HbbZbb + Paths (3/3): HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d03_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05d05_v6(L,3) HLT_DiPFJet80_DiPFJet30_BTagCSVd07d05_v6(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsL1Matched::HLT + Type IDs: 85 + Filters: hlt1PFJet40 + Paths (1/1): HLT_PFJet40_v9(L,3) Collection: hltPFJetsMatchedToCaloJets100Regional::HLT + Type IDs: 85 + Filters: hlt1PFJet140 + Paths (1/1): HLT_PFJet140_v10(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltPFJetsMatchedToCaloJets50::HLT + Type IDs: 85 + Filters: hlt1PFJet80 + Paths (1/1): HLT_PFJet80_v10(L,3) Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 + Paths (0/0): Collection: hltMediumPFTaus::HLT + Type IDs: 84 + Filters: hltDoublePFTau30 hltDoublePFTau35 + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg + Paths (0/0): Collection: hltMediumPFTausReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30Reg hltDoublePFTau35Reg + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltPFTaus::HLT + Type IDs: 84 + Filters: hltPFTau35 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 + Paths (0/0): Collection: hltSelectedMediumPFTausTrackPt1::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1 hltDoublePFTau35TrackPt1 + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackFinding::HLT + Type IDs: 84 + Filters: hltPFTau35Track + Paths (0/0): Collection: hltSelectedPFTausTrackPt1MediumIsolation::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolation hltDoublePFTau35TrackPt1MediumIsolation + Paths (0/0): Collection: hltSelectedPFTausTrackPt1MediumIsolationReg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1MediumIsolationReg hltDoublePFTau35TrackPt1MediumIsolationReg + Paths (0/0): Collection: hltSelectedPFTausTrackPt1Reg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1Reg hltDoublePFTau35TrackPt1Reg + Paths (0/0): Collection: hltSelectedPFTausTrackPt1Reg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1Reg + Paths (0/0): Collection: hltSelectedPFTausTrackPt1Reg::HLT + Type IDs: 84 + Filters: hltDoublePFTau30TrackPt1Reg hltDoublePFTau35TrackPt1Reg + Paths (0/0): Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (0/0): Collection: hltSelectedPFTausTrackPt20::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20 + Paths (0/0): Collection: hltSelectedPFTausTrackPt20Isolation::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20LooseIso + Paths (0/0): Collection: hltSelectedPFTausTrackPt20Isolation::HLT + Type IDs: 84 + Filters: hltPFTau35TrackPt20LooseIso + Paths (0/0): indx x y z rho chi2 ndf + 0 0.25 0.39 0.39 0.46 1.1e+02 1.3e+02 + 1 0.25 0.39 0.39 0.46 71 81 + 2 0.24 0.39 0.39 0.46 15 28 + 3 0.24 0.39 0.39 0.46 29 53 + 4 0.24 0.39 0.39 0.46 15 26 + 5 0.24 0.39 0.39 0.46 27 27 + 6 0.25 0.39 0.39 0.46 8.4 12 + 7 0.25 0.4 0.4 0.47 8.2 17 + 8 0.24 0.38 0.38 0.45 4.6 11 + 9 0.24 0.4 0.4 0.47 12 14 + 10 0.24 0.4 0.4 0.46 1.2 6.8 + 11 0.23 0.39 0.39 0.45 6.7 8.6 + 12 0.24 0.36 0.36 0.44 5.4 13 + 13 0.25 0.4 0.4 0.47 4.6 4.7 + 14 0.25 0.37 0.37 0.45 12 10 + 15 0.27 0.39 0.39 0.48 3.2 7 +%MSG-e ElectronBlock: ElectronBlock:electronBlock 19-Sep-2014 22:10:04 CEST Run: 1 Event: 7002051 +Error >> Failed to get pat::Electron Collection for label: InputTag: label = selectedPatElectrons, instance = +%MSG +19-Sep-2014 22:10:04 CEST Closed file root://cms-xrd-global.cern.ch//store/mc/Spring14miniaod/TTJets_MSDecaysCKM_central_Tune4C_13TeV-madgraph-tauola/MINIAODSIM/PU20bx25_POSTLS170_V5-v1/00000/F6EDDC10-8DFC-E311-BC5D-0025905A60D6.root + +============================================= + +MessageLogger Summary + + type category sev module subroutine count total + ---- -------------------- -- ---------------- ---------------- ----- ----- + 1 ElectronBlock -e ElectronBlock:el 10 10 + 2 EventBlock -e EventBlock:event 10 10 + 3 TriggerBlock -e TriggerBlock:tri 10 10 + 4 fileAction -s file_close 1 1 + 5 fileAction -s file_open 2 2 + + type category Examples: run/evt run/evt run/evt + ---- -------------------- ---------------- ---------------- ---------------- + 1 ElectronBlock 1/7002001 1/7002005 1/7002051 + 2 EventBlock 1/7002001 1/7002005 1/7002051 + 3 TriggerBlock 1/7002001 1/7002005 1/7002051 + 4 fileAction PostEndRun + 5 fileAction pre-events pre-events + +Severity # Occurrences Total Occurrences +-------- ------------- ----------------- +Error 30 30 +System 3 3 From 4244083a3b6b8b3193a213ebe3f90dc505af85be Mon Sep 17 00:00:00 2001 From: Suvankar Roy Chowdhury Date: Fri, 20 Feb 2015 19:11:01 +0530 Subject: [PATCH 2/7] Photnon + Muon Fixed --- .../TreeMaker/interface/PhysicsObjects.h | 28 +++- .../TreeMaker/plugins/ElectronBlock.cc | 81 +++++++++- .../TreeMaker/plugins/ElectronBlock.h | 3 + AnalysisSpace/TreeMaker/plugins/EventBlock.cc | 41 ++++- AnalysisSpace/TreeMaker/plugins/EventBlock.h | 13 ++ AnalysisSpace/TreeMaker/plugins/JetBlock.cc | 4 +- AnalysisSpace/TreeMaker/plugins/MuonBlock.cc | 142 ++++++++++++------ .../TreeMaker/plugins/PhotonBlock.cc | 10 +- .../TreeMaker/plugins/PhotonBlock.cc.saved2 | 69 +++++++++ AnalysisSpace/TreeMaker/plugins/PhotonBlock.h | 2 +- .../TreeMaker/python/ElectronBlock_cfi.pyc | Bin 596 -> 596 bytes .../TreeMaker/python/EventBlock_cfi.pyc | Bin 946 -> 946 bytes .../TreeMaker/python/GenEventBlock_cfi.pyc | Bin 566 -> 566 bytes .../TreeMaker/python/GenJetBlock_cfi.pyc | Bin 423 -> 423 bytes .../TreeMaker/python/GenMETBlock_cfi.pyc | Bin 419 -> 419 bytes .../TreeMaker/python/GenParticleBlock_cfi.pyc | Bin 447 -> 447 bytes .../TreeMaker/python/JetBlock_cfi.pyc | Bin 678 -> 678 bytes .../TreeMaker/python/METBlock_cfi.pyc | Bin 521 -> 521 bytes .../TreeMaker/python/MuonBlock_cfi.pyc | Bin 644 -> 644 bytes .../TreeMaker/python/PhotonBlock_cfi.py | 6 + .../TreeMaker/python/PhotonBlock_cfi.pyc | Bin 0 -> 423 bytes .../TreeMaker/python/TauBlock_cfi.pyc | Bin 574 -> 574 bytes .../TreeMaker/python/TreeContentConfig_cff.py | 2 + .../python/TreeContentConfig_cff.pyc | Bin 1206 -> 1298 bytes .../python/TreeContentConfig_data_cff.pyc | Bin 1117 -> 1117 bytes .../TreeMaker/python/TreeCreator_cfi.pyc | Bin 411 -> 411 bytes .../TreeMaker/python/TreeWriter_cfi.pyc | Bin 410 -> 410 bytes .../TreeMaker/python/TriggerBlock_cfi.pyc | Bin 672 -> 672 bytes .../python/TriggerObjectBlock_cfi.pyc | Bin 1182 -> 1182 bytes .../TreeMaker/python/VertexBlock_cfi.pyc | Bin 438 -> 438 bytes AnalysisSpace/TreeMaker/python/__init__.pyc | Bin 394 -> 394 bytes AnalysisSpace/TreeMaker/src/PhysicsObjects.cc | 21 ++- AnalysisSpace/TreeMaker/src/classes.h | 4 +- AnalysisSpace/TreeMaker/src/classes_def.xml | 11 +- 34 files changed, 376 insertions(+), 61 deletions(-) create mode 100644 AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc.saved2 create mode 100644 AnalysisSpace/TreeMaker/python/PhotonBlock_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/PhotonBlock_cfi.pyc diff --git a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h index dfb6bbc..80295c5 100644 --- a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h +++ b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h @@ -45,10 +45,16 @@ namespace vhtm { double rhoNeutral; int nvtx; + double fGridRhoAll; + double fGridRhoFastjetAll; + double fGridRhoFastjetAllCalo; + double fGridRhoFastjetCentralCalo; + double fGridRhoFastjetCentralChargedPileUp; + double fGridRhoFastjetCentralNeutral; std::vector nPU; std::vector bunchCrossing; std::vector trueNInt; - + ClassDef(Event,1) }; class GenEvent: public TObject { @@ -121,6 +127,11 @@ namespace vhtm { int missingHits; double dB; + double edB; + + double dB3D; + double edB3D; + int nBrems; float fbrem; @@ -131,6 +142,8 @@ namespace vhtm { std::map idmap; int selbit; + std::map< std::string,std::vector > isolationMap; + ClassDef(Electron, 1) }; class GenParticle: public TObject { @@ -272,6 +285,7 @@ namespace vhtm { public: Muon(); ~Muon() {} + bool isGlobalMuon; bool isTrackerMuon; bool isPFMuon; double eta; @@ -286,6 +300,8 @@ namespace vhtm { double trkDz; double globalChi2; + double tkNChi2; + float trkIso; float ecalIso; float hcalIso; @@ -313,8 +329,12 @@ namespace vhtm { double vy; double vz; - double dB; // PV2D + double dB;//2D + double edB; + double dB3D; + double edB3D; + // UW Recommendation bool isGlobalMuonPromptTight; bool isAllArbitrated; @@ -329,7 +349,7 @@ namespace vhtm { bool muonID; int selbit; - std::map< double,std::vector > isolationMap; + std::map< std::string,std::vector > isolationMap; ClassDef(Muon, 1) // ClassDef(Muon, 2) }; @@ -370,6 +390,7 @@ namespace vhtm { float combinedSecondaryVertexBTag; //double combinedSecondaryVertexMVABTag; float combinedInclusiveSecondaryVertexBTag; + float combinedInclusiveSecondaryVertexV2BJetTags; //double combinedMVABTag; std::map discrimap; @@ -477,6 +498,7 @@ namespace vhtm { bool isEBEEGap; int fidFlag; + bool passElectronVeto; bool hasPixelSeed; double ecalIso; double hcalIso; diff --git a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc index dcffe86..4dff6ce 100644 --- a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc @@ -25,9 +25,11 @@ ElectronBlock::ElectronBlock(const edm::ParameterSet& iConfig): bsTag_(iConfig.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), electronTag_(iConfig.getUntrackedParameter("electronSrc", edm::InputTag("selectedPatElectrons"))), + pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), bsToken_(consumes(bsTag_)), vertexToken_(consumes(vertexTag_)), - electronToken_(consumes(electronTag_)) + electronToken_(consumes(electronTag_)), + pfToken_(consumes(pfcandTag_)) { } ElectronBlock::~ElectronBlock() { @@ -49,6 +51,9 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe edm::Handle electrons; bool found = iEvent.getByToken(electronToken_, electrons); + edm::Handle pfs; + iEvent.getByToken(pfToken_, pfs); + if (found && electrons.isValid()) { edm::Handle beamSpot; if (bsCorr_) iEvent.getByToken(bsToken_, beamSpot); @@ -89,8 +94,9 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe electron.trkHits = hitp.numberOfValidTrackerHits(); electron.nValidHits = tk->numberOfValidHits(); - nMissingHits = tk->trackerExpectedHitsInner().numberOfHits(); - electron.missingHits = nMissingHits; +// nMissingHits = tk->trackerExpectedHitsInner().numberOfHits(); +// electron.missingHits = nMissingHits; + electron.missingHits = hitp.numberOfHits(reco::HitPattern::MISSING_INNER_HITS); double trkd0 = tk->d0(); double trkdz = tk->dz(); @@ -175,7 +181,10 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe // IP information electron.dB = v.dB(pat::Electron::PV2D); + electron.edB = v.edB(pat::Electron::PV2D); + electron.dB3D = v.dB(pat::Electron::PV3D); + electron.edB3D = v.edB(pat::Electron::PV3D); // Bremstrahlung information electron.nBrems = v.numberOfBrems(); electron.fbrem = v.fbrem(); @@ -257,6 +266,42 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe for (const pat::Electron::IdPair& pa: v.electronIDs()) electron.idmap[pa.first] = pa.second; + //Isolation from packed PF candidates + + std::vector isotemp; +// for( double cone=0.15;cone<=0.45;cone+=0.05){ +// isotemp.clear(); +// calcIsoFromPF(cone, pfs, v, isotemp); +// electron.isolationMap[cone] = isotemp; +// } + + calcIsoFromPF(0.15, pfs, v, isotemp); + electron.isolationMap["c15"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.20, pfs, v, isotemp); + electron.isolationMap["c20"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.25, pfs, v, isotemp); + electron.isolationMap["c25"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.30, pfs, v, isotemp); + electron.isolationMap["c30"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.35, pfs, v, isotemp); + electron.isolationMap["c35"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.40, pfs, v, isotemp); + electron.isolationMap["c40"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.45, pfs, v, isotemp); + electron.isolationMap["c45"] = isotemp; + list_->push_back(electron); } fnElectron_ = list_->size(); @@ -266,5 +311,35 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe << electronTag_; } } +void ElectronBlock::calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Electron& v, std::vector& iso) +{ + // initialize sums + double charged = 0, neutral = 0, pileup = 0; + // now get a list of the PF candidates used to build this lepton, so to exclude them + std::vector footprint; + for (unsigned int i = 0, n = v.numberOfSourceCandidatePtrs(); i < n; ++i) { + footprint.push_back(v.sourceCandidatePtr(i)); + } + // now loop on pf candidates + for (unsigned int i = 0, n = pfs->size(); i < n; ++i) { + const pat::PackedCandidate &pf = (*pfs)[i]; + if (deltaR(pf,v) < cone) { + //pfcandidate-based footprint removal + if (std::find(footprint.begin(), footprint.end(), reco::CandidatePtr(pfs,i)) != footprint.end()) { + continue; + } + if (pf.charge() == 0) { + if (pf.pt() > 0.5) neutral += pf.pt(); + } else if (pf.fromPV() >= 2) { + charged += pf.pt(); + } else { + if (pf.pt() > 0.5) pileup += pf.pt(); + } + } + } + iso.push_back(charged); + iso.push_back(neutral); + iso.push_back(pileup); +} #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(ElectronBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h index a474fa6..b0d950c 100644 --- a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h @@ -30,6 +30,7 @@ class ElectronBlock : public edm::EDAnalyzer virtual void beginJob(); virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + void calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Electron& v, std::vector& iso); virtual void endJob() {} public: @@ -50,9 +51,11 @@ class ElectronBlock : public edm::EDAnalyzer const edm::InputTag bsTag_; const edm::InputTag vertexTag_; const edm::InputTag electronTag_; + const edm::InputTag pfcandTag_; const edm::EDGetTokenT bsToken_; const edm::EDGetTokenT vertexToken_; const edm::EDGetTokenT electronToken_; + const edm::EDGetTokenT pfToken_; }; #endif diff --git a/AnalysisSpace/TreeMaker/plugins/EventBlock.cc b/AnalysisSpace/TreeMaker/plugins/EventBlock.cc index b113623..5485972 100644 --- a/AnalysisSpace/TreeMaker/plugins/EventBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/EventBlock.cc @@ -20,6 +20,12 @@ EventBlock::EventBlock(const edm::ParameterSet& iConfig): puSummaryTag_(iConfig.getUntrackedParameter("puSummaryTag", edm::InputTag("addPileupInfo"))), rhoTag_(iConfig.getUntrackedParameter("rhoTag", edm::InputTag("kt6PFJets","rho"))), rhoNeutralTag_(iConfig.getUntrackedParameter("rhoNeutralTag", edm::InputTag("kt6PFNeutralJetsForVtxMultReweighting", "rho"))), + fixedGridRhoAllTag_(iConfig.getUntrackedParameter("fixedGridRhoAllTag",edm::InputTag("fixedGridRhoAll"))), + fixedGridRhoFastjetAllTag_(iConfig.getUntrackedParameter("fixedGridRhoFastjetAllTag",edm::InputTag("fixedGridRhoFastjetAll"))), + fixedGridRhoFastjetAllCaloTag_(iConfig.getUntrackedParameter("fixedGridRhoFastjetAllCaloTag",edm::InputTag("fixedGridRhoFastjetAllCalo"))), + fixedGridRhoFastjetCentralCaloTag_(iConfig.getUntrackedParameter("fixedGridRhoFastjetCentralCaloTag",edm::InputTag("fixedGridRhoFastjetCentralCalo"))), + fixedGridRhoFastjetCentralChargedPileUpTag_(iConfig.getUntrackedParameter("fixedGridRhoFastjetCentralChargedPileUpTag",edm::InputTag("fixedGridRhoFastjetCentralChargedPileUp"))), + fixedGridRhoFastjetCentralNeutralTag_(iConfig.getUntrackedParameter("fixedGridRhoFastjetCentralNeutralTag",edm::InputTag("fixedGridRhoFastjetCentralNeutral"))), vtxMinNDOF_(iConfig.getUntrackedParameter("vertexMinimumNDOF", 4)), vtxMaxAbsZ_(iConfig.getUntrackedParameter("vertexMaxAbsZ", 24.)), vtxMaxd0_(iConfig.getUntrackedParameter("vertexMaxd0", 2.0)), @@ -31,7 +37,13 @@ EventBlock::EventBlock(const edm::ParameterSet& iConfig): selectedVertexToken_(consumes(selectedVertexTag_)), puSummaryToken_(consumes >(puSummaryTag_)), rhoToken_(consumes(rhoTag_)), - rhoNeutralToken_(consumes(rhoNeutralTag_)) + rhoNeutralToken_(consumes(rhoNeutralTag_)), + fixedGridRhoAllToken_(consumes(fixedGridRhoAllTag_)), + fixedGridRhoFastjetAllToken_(consumes(fixedGridRhoFastjetAllTag_)), + fixedGridRhoFastjetAllCaloToken_(consumes(fixedGridRhoFastjetAllCaloTag_)), + fixedGridRhoFastjetCentralCaloToken_(consumes(fixedGridRhoFastjetCentralCaloTag_)), + fixedGridRhoFastjetCentralChargedPileUpToken_(consumes(fixedGridRhoFastjetCentralChargedPileUpTag_)), + fixedGridRhoFastjetCentralNeutralToken_(consumes(fixedGridRhoFastjetCentralNeutralTag_)) { } EventBlock::~EventBlock() { @@ -81,6 +93,33 @@ void EventBlock::analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup edm::Handle l1GtReadoutRecord; bool found = iEvent.getByToken(l1Token_, l1GtReadoutRecord); + //Rho Part + edm::Handle fixedGridRhoAll; + iEvent.getByToken(fixedGridRhoAllToken_,fixedGridRhoAll); + ev.fGridRhoAll = *fixedGridRhoAll; + edm::Handle fixedGridRhoFastjetAll; + iEvent.getByToken(fixedGridRhoFastjetAllToken_,fixedGridRhoFastjetAll); + ev.fGridRhoFastjetAll = *fixedGridRhoFastjetAll; + edm::Handle fixedGridRhoFastjetAllCalo; + iEvent.getByToken(fixedGridRhoFastjetAllCaloToken_,fixedGridRhoFastjetAllCalo); + ev.fGridRhoFastjetAllCalo = *fixedGridRhoFastjetAllCalo; + edm::Handle fixedGridRhoFastjetCentralCalo; + iEvent.getByToken(fixedGridRhoFastjetCentralCaloToken_,fixedGridRhoFastjetCentralCalo); + ev.fGridRhoFastjetCentralCalo = *fixedGridRhoFastjetCentralCalo; + edm::Handle fixedGridRhoFastjetCentralChargedPileUp; + iEvent.getByToken(fixedGridRhoFastjetCentralChargedPileUpToken_,fixedGridRhoFastjetCentralChargedPileUp); + ev.fGridRhoFastjetCentralChargedPileUp = *fixedGridRhoFastjetCentralChargedPileUp; + edm::Handle fixedGridRhoFastjetCentralNeutral; + iEvent.getByToken(fixedGridRhoFastjetCentralNeutralToken_,fixedGridRhoFastjetCentralNeutral); + ev.fGridRhoFastjetCentralNeutral = *fixedGridRhoFastjetCentralNeutral; + // + + + + + + + // Technical Trigger Part if (found && l1GtReadoutRecord.isValid()) { diff --git a/AnalysisSpace/TreeMaker/plugins/EventBlock.h b/AnalysisSpace/TreeMaker/plugins/EventBlock.h index 38a1985..fe070d2 100644 --- a/AnalysisSpace/TreeMaker/plugins/EventBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/EventBlock.h @@ -42,6 +42,13 @@ class EventBlock : public edm::EDAnalyzer const edm::InputTag puSummaryTag_; const edm::InputTag rhoTag_; const edm::InputTag rhoNeutralTag_; + const edm::InputTag fixedGridRhoAllTag_; + const edm::InputTag fixedGridRhoFastjetAllTag_; + const edm::InputTag fixedGridRhoFastjetAllCaloTag_; + const edm::InputTag fixedGridRhoFastjetCentralCaloTag_; + const edm::InputTag fixedGridRhoFastjetCentralChargedPileUpTag_; + const edm::InputTag fixedGridRhoFastjetCentralNeutralTag_; + const unsigned int vtxMinNDOF_; const double vtxMaxAbsZ_; @@ -56,5 +63,11 @@ class EventBlock : public edm::EDAnalyzer const edm::EDGetTokenT > puSummaryToken_; const edm::EDGetTokenT rhoToken_; const edm::EDGetTokenT rhoNeutralToken_; + const edm::EDGetTokenT fixedGridRhoAllToken_; + const edm::EDGetTokenT fixedGridRhoFastjetAllToken_; + const edm::EDGetTokenT fixedGridRhoFastjetAllCaloToken_; + const edm::EDGetTokenT fixedGridRhoFastjetCentralCaloToken_; + const edm::EDGetTokenT fixedGridRhoFastjetCentralChargedPileUpToken_; + const edm::EDGetTokenT fixedGridRhoFastjetCentralNeutralToken_; }; #endif diff --git a/AnalysisSpace/TreeMaker/plugins/JetBlock.cc b/AnalysisSpace/TreeMaker/plugins/JetBlock.cc index 9e24df2..2d96338 100644 --- a/AnalysisSpace/TreeMaker/plugins/JetBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/JetBlock.cc @@ -89,7 +89,9 @@ void JetBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) jobj.combinedInclusiveSecondaryVertexBTag = jet.bDiscriminator("combinedInclusiveSecondaryVertexBJetTags"); //jobj.combinedMVABTag = jet.bDiscriminator("combinedMVABJetTags"); - + //added for 720 + jobj.combinedInclusiveSecondaryVertexV2BJetTags = jet.bDiscriminator("combinedInclusiveSecondaryVertexV2BJetTags"); + jobj.passLooseID = passjetLoose; jobj.passTightID = passjetTight; diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc index 5cd9cc1..ea5bb53 100644 --- a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc @@ -71,12 +71,9 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) edm::LogInfo("MuonBlock") << "Too many PAT Muons, fnMuon = " << list_->size(); break; } - // consider only global muons - if (!v.isGlobalMuon()) continue; - reco::TrackRef tk = v.innerTrack(); // tracker segment only - reco::TrackRef gtk = v.globalTrack(); vhtm::Muon muon; + muon.isGlobalMuon = v.isGlobalMuon() ? true : false; muon.isTrackerMuon = v.isTrackerMuon() ? true : false; muon.isPFMuon = v.isPFMuon(); @@ -86,48 +83,72 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) muon.p = v.p(); muon.energy = v.energy(); muon.charge = v.charge(); + + bool hasTkinRef = v.innerTrack().isNonnull(); + + reco::TrackRef tk; + if( hasTkinRef ) { + tk = v.innerTrack(); // tracker segment only + muon.tkNChi2 = tk->normalizedChi2(); + double trkd0 = tk->d0(); + double trkdz = tk->dz(); - double trkd0 = tk->d0(); - double trkdz = tk->dz(); - if (bsCorr_) { - if (beamSpot.isValid()) { - trkd0 = -(tk->dxy(beamSpot->position())); - trkdz = tk->dz(beamSpot->position()); - } - else - edm::LogError("MuonsBlock") << "Error >> Failed to get reco::BeamSpot for label: " - << bsTag_; - } - muon.trkD0 = trkd0; - muon.trkDz = trkdz; - muon.globalChi2 = v.normChi2(); + if (bsCorr_) { + if (beamSpot.isValid()) { + trkd0 = -(tk->dxy(beamSpot->position())); + trkdz = tk->dz(beamSpot->position()); + } + else + edm::LogError("MuonsBlock") << "Error >> Failed to get reco::BeamSpot for label: " + << bsTag_; + } + + muon.trkD0 = trkd0; + muon.trkDz = trkdz; + } + + + muon.globalChi2 = v.isGlobalMuon() ? v.normChi2() : 9999.; + muon.passID = v.muonID(muonID_) ? true : false; + double dxyWrtPV = -99.; double dzWrtPV = -99.; if (primaryVertices.isValid()) { edm::LogInfo("MuonBlock") << "Total # Primary Vertices: " << primaryVertices->size(); const reco::Vertex& vit = primaryVertices->front(); // Highest sumPt vertex - dxyWrtPV = tk->dxy(vit.position()); - dzWrtPV = tk->dz(vit.position()); + + + if( hasTkinRef ) { + dxyWrtPV = tk->dxy(vit.position()); + dzWrtPV = tk->dz(vit.position()); + } muon.dxyPV = dxyWrtPV; muon.dzPV = dzWrtPV; + // Vertex association double minVtxDist3D = 9999.; - int indexVtx = -1; + int indexVtx = -1; double vertexDistZ = 9999.; for (auto vit = primaryVertices->begin(); vit != primaryVertices->end(); ++vit) { - double dxy = tk->dxy(vit->position()); - double dz = tk->dz(vit->position()); - double dist3D = std::sqrt(pow(dxy,2) + pow(dz,2)); - if (dist3D < minVtxDist3D) { - minVtxDist3D = dist3D; - indexVtx = static_cast(std::distance(primaryVertices->begin(), vit)); - vertexDistZ = dz; + + double dxy = 9999.; + double dz = 9999.; + if( hasTkinRef ) { + dxy = tk->dxy(vit->position()); + dz = tk->dz(vit->position()); + double dist3D = std::sqrt(pow(dxy,2) + pow(dz,2)); + if (dist3D < minVtxDist3D) { + minVtxDist3D = dist3D; + indexVtx = static_cast(std::distance(primaryVertices->begin(), vit)); + vertexDistZ = dz; + } } } + muon.vtxDist3D = minVtxDist3D; muon.vtxIndex = indexVtx; muon.vtxDistZ = vertexDistZ; @@ -136,13 +157,19 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) edm::LogError("MuonBlock") << "Error >> Failed to get reco::VertexCollection for label: " << vertexTag_; } + // Hit pattern - const reco::HitPattern& hitp = gtk->hitPattern(); // innerTrack will not provide Muon Hits - muon.pixHits = hitp.numberOfValidPixelHits(); - muon.trkHits = hitp.numberOfValidTrackerHits(); - muon.muoHits = hitp.numberOfValidMuonHits(); - muon.matches = v.numberOfMatches(); - muon.trackerLayersWithMeasurement = hitp.trackerLayersWithMeasurement(); + if( hasTkinRef ) { + bool hasTkgRef = v.globalTrack().isNonnull(); + //if( hasTkgRef ) + // reco::TrackRef gtk = v.globalTrack(); + const reco::HitPattern& hitp = hasTkgRef ? v.globalTrack()->hitPattern() : tk->hitPattern(); // innerTrack will not provide Muon Hits + muon.pixHits = hitp.numberOfValidPixelHits(); + muon.trkHits = hitp.numberOfValidTrackerHits(); + muon.muoHits = hitp.numberOfValidMuonHits(); + muon.matches = v.numberOfMatches(); + muon.trackerLayersWithMeasurement = hitp.trackerLayersWithMeasurement(); + } int numMuonStations = 0; unsigned int stationMask = static_cast(v.stationMask(reco::Muon::SegmentAndTrackArbitration)); @@ -172,7 +199,10 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) // IP information muon.dB = v.dB(pat::Muon::PV2D); + muon.edB = v.edB(pat::Muon::PV2D); + muon.dB3D = v.dB(pat::Muon::PV3D); + muon.edB3D = v.edB(pat::Muon::PV3D); // UW recommendation muon.isGlobalMuonPromptTight = muon::isGoodMuon(v, muon::GlobalMuonPromptTight); muon.isAllArbitrated = muon::isGoodMuon(v, muon::AllArbitrated); @@ -183,9 +213,9 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) muon.stationGapMaskDistance = v.stationGapMaskDistance(); muon.stationGapMaskPull = v.stationGapMaskPull(); - double normalizeChi2 = v.globalTrack()->normalizedChi2(); - double ptError = v.innerTrack()->ptError()/v.innerTrack()->pt(); - + // double normalizeChi2 = v.globalTrack()->normalizedChi2(); + // double ptError = v.innerTrack()->ptError()/v.innerTrack()->pt(); + double ptError = 0.05,normalizeChi2 = 5; bool muonID = v.isGlobalMuon() && v.isTrackerMuon() && muon.isGlobalMuonPromptTight && @@ -206,14 +236,42 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) muon.vy = vertex.y(); muon.vz = vertex.z(); + //Isolation from packed PF candidates std::vector isotemp; - for( double cone=0.15;cone<=0.4;cone+=0.05){ - isotemp.clear(); - calcIsoFromPF(cone, pfs, v, isotemp); - muon.isolationMap[cone] = isotemp; - } +// for( double cone=0.15;cone<=0.45;cone+=0.05){ +// isotemp.clear(); +// calcIsoFromPF(cone, pfs, v, isotemp); +// muon.isolationMap[cone] = isotemp; +// } + calcIsoFromPF(0.15, pfs, v, isotemp); + muon.isolationMap["c15"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.20, pfs, v, isotemp); + muon.isolationMap["c20"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.25, pfs, v, isotemp); + muon.isolationMap["c25"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.30, pfs, v, isotemp); + muon.isolationMap["c30"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.35, pfs, v, isotemp); + muon.isolationMap["c35"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.40, pfs, v, isotemp); + muon.isolationMap["c40"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.45, pfs, v, isotemp); + muon.isolationMap["c45"] = isotemp; + list_->push_back(muon); } fnMuon_ = list_->size(); diff --git a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc index 126edc5..049fc1b 100644 --- a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc @@ -20,7 +20,7 @@ // Constructor PhotonBlock::PhotonBlock(const edm::ParameterSet& iConfig) : verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), - photonTag_(iConfig.getParameter("photonSrc")), + photonTag_(iConfig.getUntrackedParameter("photonSrc")), photonToken_(consumes(photonTag_)) {} void PhotonBlock::beginJob() @@ -61,6 +61,7 @@ void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetu photon.vz = v.vz(); const reco::SuperClusterRef sCluster = v.superCluster(); + //if( !sCluster ) { photon.scEnergy = sCluster->energy(); photon.scEta = sCluster->eta(); photon.scPhi = sCluster->phi(); @@ -72,6 +73,7 @@ void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetu photon.scx = sCluster->x(); photon.scy = sCluster->y(); photon.scz = sCluster->z(); + // } photon.isoEcalRecHit03 = v.ecalRecHitSumEtConeDR03(); photon.isoHcalRecHit03 = v.hcalTowerSumEtConeDR03(); @@ -124,9 +126,13 @@ void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetu photon.r2x5 = v.r2x5(); photon.maxEnergyXtal = v.maxEnergyXtal(); + photon.hasConversionTracks = v.hasConversionTracks(); + photon.passElectronVeto = v.passElectronVeto(); +/* if (v.hasConversionTracks()) { const reco::ConversionRefVector conversions = v.conversions(); + if( !conversions.empty() ) { for (edm::RefVector::const_iterator jt = conversions.begin(); jt != conversions.end(); ++jt) @@ -157,7 +163,9 @@ void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetu photon.dPhiTracksAtEcal = obj.dPhiTracksAtEcal(); photon.dEtaTracksAtEcal = obj.dEtaTracksAtEcal(); } + } } +*/ list_->push_back(photon); } fnPhoton_ = list_->size(); diff --git a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc.saved2 b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc.saved2 new file mode 100644 index 0000000..facf104 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc.saved2 @@ -0,0 +1,69 @@ +#include +#include + +#include "TTree.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" + +#include "DataFormats/GeometryVector/interface/GlobalVector.h" +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/EgammaReco/interface/SuperCluster.h" +#include "DataFormats/EgammaCandidates/interface/Conversion.h" +#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h" + +#include "AnalysisSpace/TreeMaker/plugins/PhotonBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +// Constructor +PhotonBlock::PhotonBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + photonTag_(iConfig.getUntrackedParameter("photonSrc")), + photonToken_(consumes(photonTag_)) +{} +void PhotonBlock::beginJob() +{ + // Get TTree pointer + std::string tree_name = "vhtree"; + TTree* tree = vhtm::Utility::getTree(tree_name); + list_ = new std::vector(); + tree->Branch("Photon", "std::vector", &list_, 32000, 2); + tree->Branch("nPhoton", &fnPhoton_, "fnPhoton_/I"); +} +void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the TClonesArray and the nObj variables + list_->clear(); + fnPhoton_ = 0; + + edm::Handle photons; + bool found = iEvent.getByToken(photonToken_, photons); + + if (found && photons.isValid()) { + edm::LogInfo("PhotonBlock") << "Total # PAT Photons: " << photons->size(); + std::cout << "Total # PAT Photons: " << photons->size(); + fnPhoton_ = photons->size(); + for (pat::Photon const& v: *photons) { + vhtm::Photon photon; + photon.et = v.et(); + photon.eta = v.eta(); + photon.clusterEta = v.caloPosition().eta(); + photon.phi = v.phi(); + photon.clusterPhi = v.caloPosition().phi(); + photon.energy = v.energy(); + photon.theta = v.theta(); + photon.vx = v.vx(); + photon.vy = v.vy(); + photon.vz = v.vz(); + list_->push_back(photon); + } + } + else { + edm::LogError("PhotonBlock") << "Error >> Failed to get pat::Photon for label: " + << photonTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PhotonBlock); + diff --git a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h index dca8761..25755ed 100644 --- a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h @@ -42,7 +42,7 @@ class PhotonBlock : public edm::EDAnalyzer int fnPhoton_; int verbosity_; - edm::InputTag photonTag_; + const edm::InputTag photonTag_; const edm::EDGetTokenT photonToken_; }; #endif diff --git a/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.pyc index 16664e8b31b33c5723ddfb3a4e28a1969758c80f..bd510a359f887b7b310b52261f6663917666b249 100644 GIT binary patch delta 16 Xcmcb@a)pJR`7h*?pM+GdTsq delta 16 Xcmcb@a)pJR`7h*;g|I05DDk;{X5v delta 16 YcmdnQzKNZk`7h+4Y$KFL?!M delta 16 XcmdnSvWh*%vSZ04{t5xBvhE delta 16 YcmZ3^yquYx`7h+2=3<04@9ltN;K2 delta 16 YcmZ3?yqKAt`7h*>^Ak05N<900000 delta 16 Ycmdnbyq}q!`7^Ak04~=BnE(I) diff --git a/AnalysisSpace/TreeMaker/python/JetBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/JetBlock_cfi.pyc index bd5c3f1bc9b3ea5a6d35c896044000b905273bb9..9452aceeff57f31e86d80266a82816cf3355e53c 100644 GIT binary patch delta 16 YcmZ3+x{Q^b`7h+2=C>04|jUx&QzG delta 16 YcmZ3+x{Q^b`704wkXQvd(} diff --git a/AnalysisSpace/TreeMaker/python/METBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/METBlock_cfi.pyc index b6472ab5781dcc130cd944e71b10a1d8f95af00f..1ff0ee79cb8232fa603353e4157682d7037abfdd 100644 GIT binary patch delta 16 XcmeBV>11JN{>;m@z2f*rb|xkODcJ11JN{>;nezHQP*b|xkOCo}|l diff --git a/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.pyc index 7a0927cabab45c8cbb402b21f94e1e480f0dbbf0..abd78dbbe681311d572454798daf030114cd681d 100644 GIT binary patch delta 16 XcmZo+ZDD0+{>;m@z2f*r_F5(YDpdtk delta 16 XcmZo+ZDD0+{>;nezHQP*_F5(YC$I$V diff --git a/AnalysisSpace/TreeMaker/python/PhotonBlock_cfi.py b/AnalysisSpace/TreeMaker/python/PhotonBlock_cfi.py new file mode 100644 index 0000000..ed961b8 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/PhotonBlock_cfi.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +photonBlock = cms.EDAnalyzer("PhotonBlock", + verbosity = cms.untracked.int32(1), + photonSrc = cms.untracked.InputTag('slimmedPhotons') +) diff --git a/AnalysisSpace/TreeMaker/python/PhotonBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/PhotonBlock_cfi.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39c6edadb3c83b0cc5c66ed1121e9bda3f41a182 GIT binary patch literal 423 zcmYjN%}N6?5T5Mz&ssh7=o9qR1;v|)S`~Uw3R@6*k(i`yw!6uaOoe*w3;6;*j!)nN z=p-%Jkj#AZeVHF7{W`$Bg4Lv_5Bk3|I0SX310<#oU3Pl5C0&<6&P_#fc zV9P)@qe@I0WGgURmdrY#LOuv(^)H=gJSI3Z($5m*)o|2hYenzKpC>!wGl1Qm9<6a5%DNt{2!N`H;sJ5qm8qC@PO#@(=g7 zhL@WUmkvh%T;CNx>VO;4L%IqPkOA+{s7L%Y6AcO literal 0 HcmV?d00001 diff --git a/AnalysisSpace/TreeMaker/python/TauBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/TauBlock_cfi.pyc index 634e0b8f9832275337e4cc9bd0a1b288cb1daaf0..cd2ecdfa5ec078ae8ced4fe476a0b73a46523016 100644 GIT binary patch delta 16 XcmdnTvX6zG`7h+0B^%FnI-l delta 16 XcmdnTvX6zG`78-9Q3=Ane3^@`ExsnV~k_?Qg%nVsl z45_RPsq75msiHv44aB@aEC|HHK+F%soDAa4j0{oI3@MBZ!5X}i85t8fxPfLCWaO7j z4rT0Sl-c}{k&}^8eeykKX|VvHXnvkkPJVKBd~#Z55DQRci3&(c*w-}#AsAr#C$ZX2S0g}`J>Qb6~j+u**bMj4Qb4ISof-IeKQa~voCIJv+ N1Vb3jD8R(V2LMB2K9c|d delta 191 zcmbQlwT)An`7h*~3@>G|L6& delta 16 Xcmcc1ahHRg`7GA0Fp diff --git a/AnalysisSpace/TreeMaker/python/TreeCreator_cfi.pyc b/AnalysisSpace/TreeMaker/python/TreeCreator_cfi.pyc index 37b8f2671b4180f3c9c909754d37c56a647c4137..1e4a15111458fa30e7214b2666c15892afae797f 100644 GIT binary patch delta 16 YcmbQuJe!%F`7h*{3i904)3klmGw# delta 16 YcmbQuJe!%F`7h*(Wms04&@EkpKVy delta 16 YcmbQmJd2r~`7h*=I5V04>!8r~m)} delta 16 YcmZ3$x`36P`7z>% diff --git a/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.pyc index 080f4781d12f021c2547f0cf72a0ab1e54ac5436..7e08f665933dde64209af87e3cc47cd91dfa16f0 100644 GIT binary patch delta 16 YcmbQoIggW_`7h*{8Dr04@gwtN;K2 delta 16 YcmbQoIggW_`7h+1E1y05Dty;m@z2f*r_GU%^D%=HO delta 16 XcmeBT?qX(V{>;nezHQP*_GU%^C^rQ9 diff --git a/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc b/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc index 45081c8..675b384 100644 --- a/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc +++ b/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc @@ -24,7 +24,13 @@ vhtm::Event::Event(): //isBeamScraping(false), rho(-1), rhoNeutral(-1), - nvtx(0) + nvtx(0), + fGridRhoAll(-1), + fGridRhoFastjetAll(-1), + fGridRhoFastjetAllCalo(-1), + fGridRhoFastjetCentralCalo(-1), + fGridRhoFastjetCentralChargedPileUp(-1), + fGridRhoFastjetCentralNeutral(-1) { nPU.clear(); bunchCrossing.clear(); @@ -82,6 +88,9 @@ vhtm::Electron::Electron(): sumPUPt(-999), missingHits(-1), dB(-999), + edB(-999), + dB3D(-999), + edB3D(-999), nBrems(-1), fbrem(-999), hasMatchedConv(false), @@ -198,6 +207,7 @@ vhtm::Tau::Tau(): isoGammaList.clear(); } vhtm::Muon::Muon(): + isGlobalMuon(false), isTrackerMuon(false), isPFMuon(false), eta(-999), @@ -208,7 +218,8 @@ vhtm::Muon::Muon(): charge(-999), trkD0(-999), trkDz(-999), - globalChi2(-999), + globalChi2(9999.), + tkNChi2(9999.), trkIso(-999), ecalIso(-999), hcalIso(-999), @@ -234,6 +245,9 @@ vhtm::Muon::Muon(): vy(-999), vz(-999), dB(-999), + edB(-999), + dB3D(-999), + edB3D(-999), isGlobalMuonPromptTight(false), isAllArbitrated(false), nChambers(-1), @@ -293,7 +307,7 @@ vhtm::Vertex::Vertex(): yErr(-999), zErr(-999), rho(-999), - chi2(-999), + chi2(999.), ndf(-1), //ntracks(-1), //ntracksw05(-1), @@ -350,6 +364,7 @@ vhtm::Photon::Photon(): isEEGap(false), isEBEEGap(false), fidFlag(0), + passElectronVeto(false), hasPixelSeed(false), ecalIso(-9999), hcalIso(-999), diff --git a/AnalysisSpace/TreeMaker/src/classes.h b/AnalysisSpace/TreeMaker/src/classes.h index 029cd27..2f07f14 100644 --- a/AnalysisSpace/TreeMaker/src/classes.h +++ b/AnalysisSpace/TreeMaker/src/classes.h @@ -1,7 +1,8 @@ #include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" #include - +#include +#include namespace { struct dictionary { vhtm::Event rv1; @@ -35,5 +36,6 @@ namespace { std::vector vrvf; std::vector vrvg; std::map > vrvm; + std::map< std::string, std::vector > vrvn; }; } diff --git a/AnalysisSpace/TreeMaker/src/classes_def.xml b/AnalysisSpace/TreeMaker/src/classes_def.xml index 67bdc5f..b1b7ae5 100644 --- a/AnalysisSpace/TreeMaker/src/classes_def.xml +++ b/AnalysisSpace/TreeMaker/src/classes_def.xml @@ -1,21 +1,21 @@ - + - + - + - + @@ -39,7 +39,7 @@ - + @@ -56,4 +56,5 @@ + From f97ae4a35a54c004e6fb213c5413eea4e5ab1d13 Mon Sep 17 00:00:00 2001 From: Suvankar Roy Chowdhury Date: Thu, 26 Feb 2015 15:28:01 +0530 Subject: [PATCH 3/7] changes to Photon,Muon,Electron Isolations --- AnalysisSpace/TreeMaker/BuildFile.xml | 2 + .../TreeMaker/interface/PhysicsObjects.h | 8 +- .../TreeMaker/plugins/ElectronBlock.cc | 24 +- .../TreeMaker/plugins/ElectronBlock.h | 5 + AnalysisSpace/TreeMaker/plugins/MuonBlock.cc | 3 + AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ | 255 ------------------ AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ | 51 ---- .../TreeMaker/plugins/PhotonBlock.cc | 60 ++++- AnalysisSpace/TreeMaker/plugins/PhotonBlock.h | 3 + .../TreeMaker/python/ElectronBlock_cfi.py | 3 +- .../TreeMaker/python/ElectronBlock_cfi.pyc | Bin 596 -> 670 bytes AnalysisSpace/TreeMaker/python/__init__.py | 2 +- AnalysisSpace/TreeMaker/python/__init__.pyc | Bin 394 -> 394 bytes AnalysisSpace/TreeMaker/src/PhysicsObjects.cc | 5 + AnalysisSpace/TreeMaker/src/classes_def.xml | 6 +- AnalysisSpace/TreeMaker/src/classes_def.xml~ | 60 +++++ 16 files changed, 173 insertions(+), 314 deletions(-) delete mode 100644 AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ delete mode 100644 AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ create mode 100644 AnalysisSpace/TreeMaker/src/classes_def.xml~ diff --git a/AnalysisSpace/TreeMaker/BuildFile.xml b/AnalysisSpace/TreeMaker/BuildFile.xml index 054791f..98d8475 100644 --- a/AnalysisSpace/TreeMaker/BuildFile.xml +++ b/AnalysisSpace/TreeMaker/BuildFile.xml @@ -25,6 +25,8 @@ + + diff --git a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h index 80295c5..1a83225 100644 --- a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h +++ b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h @@ -107,7 +107,7 @@ namespace vhtm { double scPhi; double scET; double scRawEnergy; - + float BDT; // Vertex association variables double dxyPV; double dzPV; @@ -122,6 +122,8 @@ namespace vhtm { float photonIso; float sumChargedHadronPt; + float sumNeutralHadronEt; + float sumPhotonEt; float sumPUPt; int missingHits; @@ -307,6 +309,8 @@ namespace vhtm { float hcalIso; float hoIso; float pfChargedIsoR03; + float pfNeutralHadIsoR03; + float pfPhotonIso03; float sumPUPt03; float pfRelIso03; float pfChargedIsoR04; @@ -539,6 +543,8 @@ namespace vhtm { int selbit; + std::map< std::string,std::vector > isolationMap; + ClassDef(Photon, 1) }; } diff --git a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc index 4dff6ce..c1a661f 100644 --- a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc @@ -1,4 +1,4 @@ -#include +#include #include #include "TFile.h" @@ -26,6 +26,7 @@ ElectronBlock::ElectronBlock(const edm::ParameterSet& iConfig): vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), electronTag_(iConfig.getUntrackedParameter("electronSrc", edm::InputTag("selectedPatElectrons"))), pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), + MVAidCollection_(iConfig.getParameter("MVAId")), bsToken_(consumes(bsTag_)), vertexToken_(consumes(vertexTag_)), electronToken_(consumes(electronTag_)), @@ -42,6 +43,22 @@ void ElectronBlock::beginJob() list_ = new std::vector(); tree->Branch("Electron", "std::vector", &list_, 32000, 2); tree->Branch("nElectron", &fnElectron_, "fnElectron_/I"); + //Electron MVA part + std::vector myManualCatWeigths; + myManualCatWeigths.push_back("EgammaAnalysis/ElectronTools/data/CSA14/TrigIDMVA_50ns_EB_BDT.weights.xml"); + myManualCatWeigths.push_back("EgammaAnalysis/ElectronTools/data/CSA14/TrigIDMVA_50ns_EE_BDT.weights.xml"); + vector myManualCatWeigthsTrig; + string the_path; + for (unsigned i = 0 ; i < myManualCatWeigths.size() ; i++){ + the_path = edm::FileInPath ( myManualCatWeigths[i] ).fullPath(); + myManualCatWeigthsTrig.push_back(the_path); + } + + myMVATrig = new EGammaMvaEleEstimatorCSA14(); + myMVATrig->initialize("BDT", + EGammaMvaEleEstimatorCSA14::kTrig, + true, + myManualCatWeigthsTrig); } void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { // Reset the vector and the nObj variables @@ -164,12 +181,17 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe electron.scET = v.superCluster()->energy()/cosh(v.superCluster()->eta()); electron.scRawEnergy = v.superCluster()->rawEnergy(); +// electron.BDT=v.electronID("mvaNonTrigV0"); + electron.BDT = myMVATrig->mvaValue(v,false); + electron.relIso = (v.trackIso() + v.ecalIso() + v.hcalIso())/v.pt(); // PF Isolation reco::GsfElectron::PflowIsolationVariables pfIso = v.pfIsolationVariables(); electron.sumChargedHadronPt = pfIso.sumChargedHadronPt; electron.sumPUPt = pfIso.sumPUPt; + electron.sumNeutralHadronEt = pfIso.sumNeutralHadronEt ; + electron.sumPhotonEt = pfIso.sumPhotonEt; float absiso = pfIso.sumChargedHadronPt + std::max(0.0, pfIso.sumNeutralHadronEt + pfIso.sumPhotonEt - 0.5 * pfIso.sumPUPt); float iso = absiso/(v.p4().pt()); electron.pfRelIso = iso; diff --git a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h index b0d950c..214214e 100644 --- a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h @@ -21,6 +21,8 @@ #include "DataFormats/BeamSpot/interface/BeamSpot.h" #include "DataFormats/EgammaCandidates/interface/GsfElectron.h" +#include "EgammaAnalysis/ElectronTools/interface/EGammaMvaEleEstimatorCSA14.h" + namespace vhtm { class Electron; } @@ -48,10 +50,13 @@ class ElectronBlock : public edm::EDAnalyzer int verbosity_; bool bsCorr_; + EGammaMvaEleEstimatorCSA14* myMVATrig; + const edm::InputTag bsTag_; const edm::InputTag vertexTag_; const edm::InputTag electronTag_; const edm::InputTag pfcandTag_; + const edm::InputTag MVAidCollection_; const edm::EDGetTokenT bsToken_; const edm::EDGetTokenT vertexToken_; diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc index ea5bb53..2701fbf 100644 --- a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc @@ -185,7 +185,10 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) // PF Isolation const reco::MuonPFIsolation& pfIso03 = v.pfIsolationR03(); muon.pfChargedIsoR03 = pfIso03.sumChargedParticlePt; + muon.pfNeutralHadIsoR03 = pfIso03.sumNeutralHadronEt; + muon.pfPhotonIso03 = pfIso03.sumPhotonEt; muon.sumPUPt03 = pfIso03.sumPUPt; + float absiso = pfIso03.sumChargedParticlePt + std::max(0.0, pfIso03.sumNeutralHadronEt + pfIso03.sumPhotonEt - 0.5 * pfIso03.sumPUPt); float iso = absiso/(v.p4().pt()); muon.pfRelIso03 = iso; diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ deleted file mode 100644 index ea2adf3..0000000 --- a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc~ +++ /dev/null @@ -1,255 +0,0 @@ -#include - -#include "TTree.h" - -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "CommonTools/UtilAlgos/interface/TFileService.h" -#include "DataFormats/PatCandidates/interface/Muon.h" -#include "DataFormats/TrackReco/interface/HitPattern.h" -#include "DataFormats/BeamSpot/interface/BeamSpot.h" -#include "DataFormats/VertexReco/interface/Vertex.h" -#include "DataFormats/VertexReco/interface/VertexFwd.h" -#include "DataFormats/PatCandidates/interface/PackedCandidate.h" -#include "Math/GenVector/VectorUtil.h" -#include "DataFormats/Math/interface/deltaR.h" - -#include "DataFormats/GeometryVector/interface/GlobalPoint.h" -#include "DataFormats/GeometryVector/interface/VectorUtil.h" - -#include "DataFormats/MuonReco/interface/MuonIsolation.h" -#include "DataFormats/MuonReco/interface/MuonPFIsolation.h" - -#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" -#include "AnalysisSpace/TreeMaker/plugins/MuonBlock.h" -#include "AnalysisSpace/TreeMaker/interface/Utility.h" - -MuonBlock::MuonBlock(const edm::ParameterSet& iConfig): - verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), - muonTag_(iConfig.getUntrackedParameter("muonSrc", edm::InputTag("selectedPatMuons"))), - vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), - bsTag_(iConfig.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), - pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), - bsCorr_(iConfig.getUntrackedParameter("beamSpotCorr", true)), - muonID_(iConfig.getUntrackedParameter("muonID", "GlobalMuonPromptTight")), - muonToken_(consumes(muonTag_)), - vertexToken_(consumes(vertexTag_)), - bsToken_(consumes(bsTag_)), - pfToken_(consumes(pfcandTag_)) -{ -} -MuonBlock::~MuonBlock() { -} -void MuonBlock::beginJob() -{ - // Get TTree pointer - TTree* tree = vhtm::Utility::getTree("vhtree"); - list_ = new std::vector(); - tree->Branch("Muon", "std::vector", &list_, 32000, 2); - tree->Branch("nMuon", &fnMuon_, "fnMuon_/I"); -} -void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { - // Reset the vector and the nObj variables - list_->clear(); - fnMuon_ = 0; - - edm::Handle muons; - bool found = iEvent.getByToken(muonToken_, muons); - - edm::Handle pfs; - iEvent.getByToken(pfToken_, pfs); - - if (found && muons.isValid()) { - edm::Handle primaryVertices; - iEvent.getByToken(vertexToken_, primaryVertices); - - edm::Handle beamSpot; - iEvent.getByToken(bsToken_, beamSpot); - - edm::LogInfo("MuonBlock") << "Total # of Muons: " << muons->size(); - for (const pat::Muon& v: *muons) { - if (list_->size() == kMaxMuon_) { - edm::LogInfo("MuonBlock") << "Too many PAT Muons, fnMuon = " << list_->size(); - break; - } - // consider only global muons - if (!v.isGlobalMuon()) continue; - reco::TrackRef tk = v.innerTrack(); // tracker segment only - reco::TrackRef gtk = v.globalTrack(); - - vhtm::Muon muon; - muon.isTrackerMuon = v.isTrackerMuon() ? true : false; - muon.isPFMuon = v.isPFMuon(); - - muon.eta = v.eta(); - muon.phi = v.phi(); - muon.pt = v.pt(); - muon.p = v.p(); - muon.energy = v.energy(); - muon.charge = v.charge(); - - double trkd0 = tk->d0(); - double trkdz = tk->dz(); - if (bsCorr_) { - if (beamSpot.isValid()) { - trkd0 = -(tk->dxy(beamSpot->position())); - trkdz = tk->dz(beamSpot->position()); - } - else - edm::LogError("MuonsBlock") << "Error >> Failed to get reco::BeamSpot for label: " - << bsTag_; - } - muon.trkD0 = trkd0; - muon.trkDz = trkdz; - muon.globalChi2 = v.normChi2(); - muon.passID = v.muonID(muonID_) ? true : false; - - double dxyWrtPV = -99.; - double dzWrtPV = -99.; - if (primaryVertices.isValid()) { - edm::LogInfo("MuonBlock") << "Total # Primary Vertices: " << primaryVertices->size(); - - const reco::Vertex& vit = primaryVertices->front(); // Highest sumPt vertex - dxyWrtPV = tk->dxy(vit.position()); - dzWrtPV = tk->dz(vit.position()); - muon.dxyPV = dxyWrtPV; - muon.dzPV = dzWrtPV; - - // Vertex association - double minVtxDist3D = 9999.; - int indexVtx = -1; - double vertexDistZ = 9999.; - for (auto vit = primaryVertices->begin(); vit != primaryVertices->end(); ++vit) { - double dxy = tk->dxy(vit->position()); - double dz = tk->dz(vit->position()); - double dist3D = std::sqrt(pow(dxy,2) + pow(dz,2)); - if (dist3D < minVtxDist3D) { - minVtxDist3D = dist3D; - indexVtx = static_cast(std::distance(primaryVertices->begin(), vit)); - vertexDistZ = dz; - } - } - muon.vtxDist3D = minVtxDist3D; - muon.vtxIndex = indexVtx; - muon.vtxDistZ = vertexDistZ; - } - else { - edm::LogError("MuonBlock") << "Error >> Failed to get reco::VertexCollection for label: " - << vertexTag_; - } - // Hit pattern - const reco::HitPattern& hitp = gtk->hitPattern(); // innerTrack will not provide Muon Hits - muon.pixHits = hitp.numberOfValidPixelHits(); - muon.trkHits = hitp.numberOfValidTrackerHits(); - muon.muoHits = hitp.numberOfValidMuonHits(); - muon.matches = v.numberOfMatches(); - muon.trackerLayersWithMeasurement = hitp.trackerLayersWithMeasurement(); - - int numMuonStations = 0; - unsigned int stationMask = static_cast(v.stationMask(reco::Muon::SegmentAndTrackArbitration)); - for (int i = 0; i < 8; ++i) // eight stations, eight bits - if (stationMask & (1<normalizedChi2(); - double ptError = v.innerTrack()->ptError()/v.innerTrack()->pt(); - - bool muonID = v.isGlobalMuon() && - v.isTrackerMuon() && - muon.isGlobalMuonPromptTight && - muon.isAllArbitrated && - std::fabs(dxyWrtPV) < 0.02 && - std::fabs(dzWrtPV) < 0.2 && - normalizeChi2 < 10 && - ptError < 0.1 && - muon.trkHits >= 10 && - muon.pixHits >= 1 && - numMuonStations >= 2 && - muon.nMatches >= 1; - muon.muonID = muonID; - - // Vertex information - const reco::Candidate::Point& vertex = v.vertex(); - muon.vx = vertex.x(); - muon.vy = vertex.y(); - muon.vz = vertex.z(); - - //Isolation from packed PF candidates - std::vector isotemp; - calcIsoFromPF(0.2,pfs,v,isotemp); - isolationMap[0.2]=isotemp; - - list_->push_back(muon); - } - fnMuon_ = list_->size(); - } - else { - edm::LogError("MuonBlock") << "Error >> Failed to get pat::Muon collection for label: " - << muonTag_; - } -} - -void MuonBlock::calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Muon& v, std::vector& iso) -{ - // initialize sums - double charged = 0, neutral = 0, pileup = 0; - // now get a list of the PF candidates used to build this lepton, so to exclude them - std::vector footprint; - for (unsigned int i = 0, n = v.numberOfSourceCandidatePtrs(); i < n; ++i) { - footprint.push_back(v.sourceCandidatePtr(i)); - } - // now loop on pf candidates - for (unsigned int i = 0, n = pfs->size(); i < n; ++i) { - const pat::PackedCandidate &pf = (*pfs)[i]; - if (deltaR(pf,v) < cone) { - //pfcandidate-based footprint removal - if (std::find(footprint.begin(), footprint.end(), reco::CandidatePtr(pfs,i)) != footprint.end()) { - continue; - } - if (pf.charge() == 0) { - if (pf.pt() > 0.5) neutral += pf.pt(); - } else if (pf.fromPV() >= 2) { - charged += pf.pt(); - } else { - if (pf.pt() > 0.5) pileup += pf.pt(); - } - } - } - iso.push_back(charged); - iso.push_back(neutral); - iso.push_back(pileup); -} -#include "FWCore/Framework/interface/MakerMacros.h" -DEFINE_FWK_MODULE(MuonBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ deleted file mode 100644 index 52462c6..0000000 --- a/AnalysisSpace/TreeMaker/plugins/MuonBlock.h~ +++ /dev/null @@ -1,51 +0,0 @@ -#ifndef __AnalysisSpace_TreeMaker_MuonBlock_h -#define __AnalysisSpace_TreeMaker_MuonBlock_h - -#include -#include - -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/EDAnalyzer.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/ServiceRegistry/interface/Service.h" - -namespace vhtm { - class Muon; -} -class MuonBlock : public edm::EDAnalyzer -{ - private: - virtual void beginJob(); - virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} - virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); - virtual void endJob(){} - void calcIsoFromPF(double cone, const pat::PackedCandidateCollection pfs, const pat::Muon& v, std::vector& iso); - public: - explicit MuonBlock(const edm::ParameterSet& iConfig); - virtual ~MuonBlock(); - - enum { - kMaxMuon_ = 100 - }; - - private: - std::vector* list_; - int fnMuon_; - - const int verbosity_; - - const edm::InputTag muonTag_; - const edm::InputTag vertexTag_; - const edm::InputTag bsTag_; - const edm::InputTag pfcandTag_; - - const bool bsCorr_; - const std::string muonID_; - - const edm::EDGetTokenT muonToken_; - const edm::EDGetTokenT vertexToken_; - const edm::EDGetTokenT bsToken_; - const edm::EDGetTokenT pfToken_; -}; -#endif diff --git a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc index 049fc1b..048e600 100644 --- a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc @@ -13,6 +13,7 @@ #include "DataFormats/EgammaReco/interface/SuperCluster.h" #include "DataFormats/EgammaCandidates/interface/Conversion.h" #include "DataFormats/EgammaCandidates/interface/ConversionFwd.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" #include "AnalysisSpace/TreeMaker/plugins/PhotonBlock.h" #include "AnalysisSpace/TreeMaker/interface/Utility.h" @@ -21,7 +22,9 @@ PhotonBlock::PhotonBlock(const edm::ParameterSet& iConfig) : verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), photonTag_(iConfig.getUntrackedParameter("photonSrc")), - photonToken_(consumes(photonTag_)) + pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), + photonToken_(consumes(photonTag_)), + pfToken_(consumes(pfcandTag_)) {} void PhotonBlock::beginJob() { @@ -40,6 +43,9 @@ void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetu edm::Handle photons; bool found = iEvent.getByToken(photonToken_, photons); + edm::Handle pfs; + iEvent.getByToken(pfToken_, pfs); + if (found && photons.isValid()) { edm::LogInfo("PhotonBlock") << "Total # PAT Photons: " << photons->size(); for (pat::Photon const& v: *photons) { @@ -166,6 +172,28 @@ void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetu } } */ + std::vector isotemp; + calcIsoFromPF(0.15, pfs, v, isotemp); + photon.isolationMap["c15"] = isotemp; + isotemp.clear(); + calcIsoFromPF(0.20, pfs, v, isotemp); + photon.isolationMap["c20"] = isotemp; + isotemp.clear(); + calcIsoFromPF(0.25, pfs, v, isotemp); + photon.isolationMap["c25"] = isotemp; + isotemp.clear(); + calcIsoFromPF(0.30, pfs, v, isotemp); + photon.isolationMap["c30"] = isotemp; + isotemp.clear(); + calcIsoFromPF(0.35, pfs, v, isotemp); + photon.isolationMap["c35"] = isotemp; + isotemp.clear(); + calcIsoFromPF(0.40, pfs, v, isotemp); + photon.isolationMap["c40"] = isotemp; + isotemp.clear(); + calcIsoFromPF(0.45, pfs, v, isotemp); + photon.isolationMap["c45"] = isotemp; + list_->push_back(photon); } fnPhoton_ = list_->size(); @@ -175,6 +203,36 @@ void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetu << photonTag_; } } +void PhotonBlock::calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Photon& v, std::vector& iso) +{ + // initialize sums + double charged = 0, neutral = 0, pileup = 0; + // now get a list of the PF candidates used to build this lepton, so to exclude them + std::vector footprint; + for (unsigned int i = 0, n = v.numberOfSourceCandidatePtrs(); i < n; ++i) { + footprint.push_back(v.sourceCandidatePtr(i)); + } + // now loop on pf candidates + for (unsigned int i = 0, n = pfs->size(); i < n; ++i) { + const pat::PackedCandidate &pf = (*pfs)[i]; + if (deltaR(pf,v) < cone) { + //pfcandidate-based footprint removal + if (std::find(footprint.begin(), footprint.end(), reco::CandidatePtr(pfs,i)) != footprint.end()) + continue; + + if (pf.charge() == 0) { + if (pf.pt() > 0.5) neutral += pf.pt(); + } else if (pf.fromPV() >= 2) { + if( pf.pt() > 0.2 ) charged += pf.pt(); + } else { + if (pf.pt() > 0.5) pileup += pf.pt(); + } + } + } + iso.push_back(charged); + iso.push_back(neutral); + iso.push_back(pileup); +} #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PhotonBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h index 25755ed..5843bfb 100644 --- a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.h @@ -28,6 +28,7 @@ class PhotonBlock : public edm::EDAnalyzer virtual void beginJob(); virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + void calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Photon& v, std::vector& iso); virtual void endJob() {} public: @@ -43,6 +44,8 @@ class PhotonBlock : public edm::EDAnalyzer int verbosity_; const edm::InputTag photonTag_; + const edm::InputTag pfcandTag_; const edm::EDGetTokenT photonToken_; + const edm::EDGetTokenT pfToken_; }; #endif diff --git a/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.py b/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.py index 8ecdb68..a6a60eb 100644 --- a/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.py @@ -5,5 +5,6 @@ beamSpotCorr = cms.untracked.bool(True), offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot'), vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), - electronSrc = cms.untracked.InputTag('slimmedElectrons') + electronSrc = cms.untracked.InputTag('slimmedElectrons'), + MVAId = cms.InputTag("mvaTrigV050nsCSA14","","addMVAid") ) diff --git a/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.pyc b/AnalysisSpace/TreeMaker/python/ElectronBlock_cfi.pyc index bd510a359f887b7b310b52261f6663917666b249..8a0a1c06e9472da801a61b3365c67f4a57b44b77 100644 GIT binary patch delta 147 zcmcb@GLKc7`7BKv9Mg c4j_@3k^)qinKId(@vjgcP(X-@hfxR)0U44V!vFvP delta 72 zcmbQodWA)r`7n$qZ1y3#1)@xVV0zbOlc{BWn~FLkc59um<;neweIai_GOG_6W84V07JM3qyPW_ delta 20 ccmeBT?qX(V{>;m@z2f*p_GOHw6W84V07UTzv;Y7A diff --git a/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc b/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc index 675b384..f59f256 100644 --- a/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc +++ b/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc @@ -74,6 +74,7 @@ vhtm::Electron::Electron(): scPhi(-999), scET(-999), scRawEnergy(-999), + BDT(-999), dxyPV(-999), dzPV(-999), vtxDist3D(-999), @@ -85,6 +86,8 @@ vhtm::Electron::Electron(): neutralHadronIso(-999), photonIso(-999), sumChargedHadronPt(-999), + sumNeutralHadronEt(-999.), + sumPhotonEt(-999.), sumPUPt(-999), missingHits(-1), dB(-999), @@ -225,6 +228,8 @@ vhtm::Muon::Muon(): hcalIso(-999), hoIso(-999), pfChargedIsoR03(-999), + pfNeutralHadIsoR03(999.), + pfPhotonIso03(999.), sumPUPt03(-999), pfRelIso03(-1), pfChargedIsoR04(-999), diff --git a/AnalysisSpace/TreeMaker/src/classes_def.xml b/AnalysisSpace/TreeMaker/src/classes_def.xml index b1b7ae5..d4c3dd6 100644 --- a/AnalysisSpace/TreeMaker/src/classes_def.xml +++ b/AnalysisSpace/TreeMaker/src/classes_def.xml @@ -6,13 +6,13 @@ - + - + @@ -39,7 +39,7 @@ - + diff --git a/AnalysisSpace/TreeMaker/src/classes_def.xml~ b/AnalysisSpace/TreeMaker/src/classes_def.xml~ new file mode 100644 index 0000000..252a78e --- /dev/null +++ b/AnalysisSpace/TreeMaker/src/classes_def.xml~ @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From c998d74e60b392b9bbde5cb34a0ea5d8eb0d6131 Mon Sep 17 00:00:00 2001 From: Suvankar Roy Chowdhury Date: Mon, 9 Mar 2015 11:15:40 +0530 Subject: [PATCH 4/7] Added PackedPFCandidate --- .../TreeMaker/interface/PhysicsObjects.h | 31 ++++++- .../plugins/PackedPFCandidateBlock.cc | 86 +++++++++++++++++++ .../plugins/PackedPFCandidateBlock.h | 48 +++++++++++ .../python/PackedPFCandidateBlock_cfi.py | 6 ++ .../TreeMaker/python/TreeContentConfig_cff.py | 2 + AnalysisSpace/TreeMaker/src/PhysicsObjects.cc | 17 ++++ AnalysisSpace/TreeMaker/src/classes.h | 4 +- AnalysisSpace/TreeMaker/src/classes_def.xml | 4 + 8 files changed, 196 insertions(+), 2 deletions(-) create mode 100644 AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc create mode 100644 AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h create mode 100644 AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py diff --git a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h index 1a83225..bc0dfe8 100644 --- a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h +++ b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h @@ -17,9 +17,38 @@ namespace vhtm { float pt; float eta; float phi; - + ClassDef(Candidate,1) }; + + class PackedPFCandidate: public TObject { + public: + PackedPFCandidate(); + //Candidate(float pt, float eta, float phi); + virtual ~PackedPFCandidate() {} + + float pt; + float eta; + float phi; + float energy; + + int pdgId; + int charge; + + double vx; + double vy; + double vz; + + int fromPV; + //w.r.t PV + float dxy; + float dz; + float dxyError; + float dzError; + + ClassDef(PackedPFCandidate,1) + }; + class Event: public TObject { public: Event(); diff --git a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc new file mode 100644 index 0000000..b8c6e4d --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc @@ -0,0 +1,86 @@ +#include +#include + +#include "TTree.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" + +#include "DataFormats/GeometryVector/interface/GlobalVector.h" +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +// Constructor +PackedPFCandidateBlock::PackedPFCandidateBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), + pfToken_(consumes(pfcandTag_)) +{} +void PackedPFCandidateBlock::beginJob() +{ + // Get TTree pointer + std::string tree_name = "vhtree"; + TTree* tree = vhtm::Utility::getTree(tree_name); + list_ = new std::vector(); + tree->Branch("PackedPFCandidate", "std::vector", &list_, 32000, 2); + tree->Branch("nPackedPFCandidate", &fnPackedPFCandidate_, "fnPackedPFCandidate_/I"); +} +void PackedPFCandidateBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the TClonesArray and the nObj variables + list_->clear(); + fnPackedPFCandidate_ = 0; + + edm::Handle pfs; + iEvent.getByToken(pfToken_, pfs); + + + if ( pfs.isValid()) { + edm::LogInfo("PackedPFCandidateBlock") << "Total # PackedPFCandidate: " << pfs->size(); + for (pat::PackedCandidate const& v: *pfs) { + //if (list_->size() == kMaxPhoton) { + // edm::LogInfo("PackedPFCandidate") << "Too many PAT Photon, fnPhoton = " + // << fnPhoton_; + // break; + //} + + int pdg = v.pdgId(); + if( pdg != std::abs(11) || pdg != std::abs(13) || + pdg != std::abs(15) || pdg != std::abs(22) + ) continue; + + vhtm::PackedPFCandidate pfCand; + + pfCand.pt = v.pt(); + pfCand.eta = v.eta(); + pfCand.phi = v.phi(); + pfCand.energy = v.energy(); + + pfCand.pdgId = pdg; + pfCand.charge = v.charge(); + + pfCand.vx = v.vx(); + pfCand.vz = v.vz(); + pfCand.vz = v.vz(); + + pfCand.fromPV = v.fromPV(); + pfCand.dxy = v.dxy(); + pfCand.dz = v.dz(); + pfCand.dxyError = v.dxyError(); + pfCand.dzError = v.dzError(); + + list_->push_back(pfCand); + } + fnPackedPFCandidate_ = list_->size(); + } + else { + edm::LogError("PackedPFCandidateBlock") << "Error >> Failed to get pat::Photon for label: " + << pfcandTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PackedPFCandidateBlock); + diff --git a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h new file mode 100644 index 0000000..ebb9ddd --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h @@ -0,0 +1,48 @@ +#ifndef __AnalysisSpace_TreeMaker_PackedCandidateBlock_h +#define __AnalysisSpace_TreeMaker_PackedCandidateBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/Common/interface/Ref.h" + +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Provenance/interface/EventID.h" +#include "FWCore/ParameterSet/interface/ProcessDesc.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" + +namespace vhtm { + class PackedPFCandidate; +} + +class PackedPFCandidateBlock : public edm::EDAnalyzer +{ + private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + + public: + explicit PackedPFCandidateBlock(const edm::ParameterSet& iConfig); + virtual ~PackedPFCandidateBlock() {} + + enum { + kMaxPackedPFCandidate = 100 + }; + private: + std::vector* list_; + int fnPackedPFCandidate_; + + int verbosity_; + const edm::InputTag pfcandTag_; + const edm::EDGetTokenT pfToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py b/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py new file mode 100644 index 0000000..682c2a3 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +packedPFCandidateBlock = cms.EDAnalyzer("PackedPFCandidateBlock", + verbosity = cms.untracked.int32(1), + pfCands = cms.untracked.InputTag('packedPFCandidates') +) diff --git a/AnalysisSpace/TreeMaker/python/TreeContentConfig_cff.py b/AnalysisSpace/TreeMaker/python/TreeContentConfig_cff.py index ff650da..bcc76be 100644 --- a/AnalysisSpace/TreeMaker/python/TreeContentConfig_cff.py +++ b/AnalysisSpace/TreeMaker/python/TreeContentConfig_cff.py @@ -14,6 +14,7 @@ from AnalysisSpace.TreeMaker.GenParticleBlock_cfi import genParticleBlock from AnalysisSpace.TreeMaker.TriggerBlock_cfi import triggerBlock from AnalysisSpace.TreeMaker.TriggerObjectBlock_cfi import triggerObjectBlock +from AnalysisSpace.TreeMaker.PackedPFCandidateBlock_cfi import packedPFCandidateBlock treeContentSequence = cms.Sequence( eventBlock @@ -30,4 +31,5 @@ + tauBlock + metBlock + jetBlock + + packedPFCandidateBlock ) diff --git a/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc b/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc index f59f256..7719728 100644 --- a/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc +++ b/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc @@ -8,6 +8,23 @@ vhtm::Candidate::Candidate(): vhtm::Candidate::Candidate(float _pt, float _eta, float _phi): pt(_pt), eta(_eta), phi(_phi) {} +vhtm::PackedPFCandidate::PackedPFCandidate(): + pt(-999.), + eta(-999.), + phi(-999.), + energy(-999.), + pdgId(0), + charge(-999), + vx(-999.), + vy(-999.), + vz(-999.), + fromPV(-999), + dxy(-999.), + dz(-999.), + dxyError(-999.), + dzError(-999.) +{} + vhtm::Event::Event(): run(0), event(0), diff --git a/AnalysisSpace/TreeMaker/src/classes.h b/AnalysisSpace/TreeMaker/src/classes.h index 2f07f14..3036868 100644 --- a/AnalysisSpace/TreeMaker/src/classes.h +++ b/AnalysisSpace/TreeMaker/src/classes.h @@ -19,6 +19,7 @@ namespace { vhtm::TriggerObject rvd; vhtm::Candidate rve; vhtm::Photon rvf; + vhtm::PackedPFCandidate rvg; std::vector vrv1; std::vector vrv2; @@ -34,7 +35,8 @@ namespace { std::vector vrvd; std::vector vrve; std::vector vrvf; - std::vector vrvg; + std::vector vrvg; + std::vector vrvl; std::map > vrvm; std::map< std::string, std::vector > vrvn; }; diff --git a/AnalysisSpace/TreeMaker/src/classes_def.xml b/AnalysisSpace/TreeMaker/src/classes_def.xml index d4c3dd6..7cd2343 100644 --- a/AnalysisSpace/TreeMaker/src/classes_def.xml +++ b/AnalysisSpace/TreeMaker/src/classes_def.xml @@ -41,6 +41,9 @@ + + + @@ -55,6 +58,7 @@ + From 702dc21e0930bfb41a0d30e1470f752c301c0f04 Mon Sep 17 00:00:00 2001 From: Suvankar Roy Chowdhury Date: Mon, 9 Mar 2015 14:59:54 +0530 Subject: [PATCH 5/7] PackedPFCandidate pdg fix --- .../TreeMaker/plugins/PackedPFCandidateBlock.cc | 13 ++++++++----- .../TreeMaker/plugins/PackedPFCandidateBlock.h | 3 +++ .../TreeMaker/python/PackedPFCandidateBlock_cfi.py | 3 ++- 3 files changed, 13 insertions(+), 6 deletions(-) diff --git a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc index b8c6e4d..09c3068 100644 --- a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc @@ -18,6 +18,7 @@ PackedPFCandidateBlock::PackedPFCandidateBlock(const edm::ParameterSet& iConfig) : verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), + pdgTosave_(iConfig.getParameter>("pdgTosave")), pfToken_(consumes(pfcandTag_)) {} void PackedPFCandidateBlock::beginJob() @@ -47,10 +48,12 @@ void PackedPFCandidateBlock::analyze(const edm::Event& iEvent, const edm::EventS // break; //} - int pdg = v.pdgId(); - if( pdg != std::abs(11) || pdg != std::abs(13) || - pdg != std::abs(15) || pdg != std::abs(22) - ) continue; + int pdg = std::abs(v.pdgId()); + if( std::find(pdgTosave_.begin(), pdgTosave_.end(), pdg) == pdgTosave_.end() ) continue; + + //if( pdg != std::abs(11) && pdg != std::abs(13) && + // pdg != std::abs(15) && pdg != std::abs(22) + // ) continue; vhtm::PackedPFCandidate pfCand; @@ -59,7 +62,7 @@ void PackedPFCandidateBlock::analyze(const edm::Event& iEvent, const edm::EventS pfCand.phi = v.phi(); pfCand.energy = v.energy(); - pfCand.pdgId = pdg; + pfCand.pdgId = v.pdgId(); pfCand.charge = v.charge(); pfCand.vx = v.vx(); diff --git a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h index ebb9ddd..d58b468 100644 --- a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h @@ -43,6 +43,9 @@ class PackedPFCandidateBlock : public edm::EDAnalyzer int verbosity_; const edm::InputTag pfcandTag_; + + std::vector pdgTosave_; + const edm::EDGetTokenT pfToken_; }; #endif diff --git a/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py b/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py index 682c2a3..f12e26f 100644 --- a/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py @@ -2,5 +2,6 @@ packedPFCandidateBlock = cms.EDAnalyzer("PackedPFCandidateBlock", verbosity = cms.untracked.int32(1), - pfCands = cms.untracked.InputTag('packedPFCandidates') + pfCands = cms.untracked.InputTag('packedPFCandidates'), + pdgTosave = cms.vint32( 11,13,15,22 ) ) From 7bbc3524482dfc3a79956bfd938b51c8ca618416 Mon Sep 17 00:00:00 2001 From: Suvankar Roy Chowdhury Date: Fri, 4 Dec 2015 15:22:30 +0100 Subject: [PATCH 6/7] changes for CMSSW_7_4_14 --- AnalysisSpace/TreeMaker/compile.log | 66 ++++ .../TreeMaker/interface/PhysicsObjects.h | 27 +- .../TreeMaker/plugins/ElectronBlock.cc | 86 +++-- .../TreeMaker/plugins/ElectronBlock.h | 22 +- AnalysisSpace/TreeMaker/plugins/EventBlock.cc | 2 +- .../TreeMaker/plugins/GenEventBlock.cc | 2 +- .../TreeMaker/plugins/GenJetBlock.cc | 2 +- .../TreeMaker/plugins/GenMETBlock.cc | 2 +- .../TreeMaker/plugins/GenParticleBlock.cc | 2 +- AnalysisSpace/TreeMaker/plugins/JetBlock.cc | 6 +- AnalysisSpace/TreeMaker/plugins/METBlock.cc | 11 +- AnalysisSpace/TreeMaker/plugins/MuonBlock.cc | 200 +++++++++-- .../TreeMaker/plugins/MuonBlock.cc.saved | 337 ++++++++++++++++++ AnalysisSpace/TreeMaker/plugins/MuonBlock.h | 11 + .../plugins/PackedPFCandidateBlock.cc | 99 +++-- .../plugins/PackedPFCandidateBlock.h | 13 +- .../TreeMaker/plugins/PhotonBlock.cc | 2 +- AnalysisSpace/TreeMaker/plugins/TauBlock.cc | 2 +- .../TreeMaker/plugins/TriggerBlock.cc | 93 ++++- .../TreeMaker/plugins/TriggerBlock.h | 13 +- .../TreeMaker/plugins/TriggerObjectBlock.cc | 110 ++++-- .../plugins/TriggerObjectBlock.cc.saved | 117 ++++++ .../TreeMaker/plugins/TriggerObjectBlock.h | 18 +- .../plugins/TriggerObjectBlock.h.saved | 60 ++++ .../TreeMaker/plugins/VertexBlock.cc | 2 +- .../CalibratedElectronBlock_bx25_cfi.py | 17 + .../python/ElectronBlock_bx25_cfi.py | 17 + .../python/ElectronBlock_bx25_cfi.py.CSA14 | 17 + .../python/ElectronBlock_bx50_cfi.py | 16 + .../TreeMaker/python/EventBlock_cfi.py | 4 +- .../TreeMaker/python/MuonBlock_cfi.py | 4 +- .../python/PackedPFCandidateBlock_cfi.py | 4 +- .../TreeMaker/python/TauBlock_cfi.py | 3 +- .../TreeContentConfig_bx25_DYJets_cff.py | 35 ++ .../python/TreeContentConfig_bx25_cff.py | 37 ++ .../python/TreeContentConfig_bx50_cff.py | 35 ++ .../python/TreeContentConfig_data_cff.py | 8 +- .../TreeMaker/python/TriggerBlock_cfi.py | 21 +- .../python/TriggerObjectBlock_cfi.py | 36 +- .../python/TriggerObjectBlock_cfi.py~ | 8 + .../TreeMaker/python/VertexBlock_cfi.py | 5 +- AnalysisSpace/TreeMaker/python/__init__.py | 2 +- AnalysisSpace/TreeMaker/src/PhysicsObjects.cc | 44 ++- AnalysisSpace/TreeMaker/src/classes_def.xml | 30 +- .../test/miniAODprod_MCbx25_V2_SYNC23OCT.py | 152 ++++++++ .../test/miniAODprod_MCbx25_V2_ecalib.py | 102 ++++++ 46 files changed, 1657 insertions(+), 245 deletions(-) create mode 100644 AnalysisSpace/TreeMaker/compile.log create mode 100644 AnalysisSpace/TreeMaker/plugins/MuonBlock.cc.saved create mode 100644 AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc.saved create mode 100644 AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h.saved create mode 100644 AnalysisSpace/TreeMaker/python/CalibratedElectronBlock_bx25_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/ElectronBlock_bx25_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/ElectronBlock_bx25_cfi.py.CSA14 create mode 100644 AnalysisSpace/TreeMaker/python/ElectronBlock_bx50_cfi.py create mode 100644 AnalysisSpace/TreeMaker/python/TreeContentConfig_bx25_DYJets_cff.py create mode 100644 AnalysisSpace/TreeMaker/python/TreeContentConfig_bx25_cff.py create mode 100644 AnalysisSpace/TreeMaker/python/TreeContentConfig_bx50_cff.py create mode 100644 AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py~ create mode 100644 AnalysisSpace/TreeMaker/test/miniAODprod_MCbx25_V2_SYNC23OCT.py create mode 100644 AnalysisSpace/TreeMaker/test/miniAODprod_MCbx25_V2_ecalib.py diff --git a/AnalysisSpace/TreeMaker/compile.log b/AnalysisSpace/TreeMaker/compile.log new file mode 100644 index 0000000..d46a337 --- /dev/null +++ b/AnalysisSpace/TreeMaker/compile.log @@ -0,0 +1,66 @@ +>> Local Products Rules ..... started +>> Local Products Rules ..... done +>> Entering Package AnalysisSpace/TreeMaker +>> Creating project symlinks + src/AnalysisSpace/TreeMaker/python -> python/AnalysisSpace/TreeMaker +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/METBlock.cc +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/TauBlock.cc +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/TreeMakerModule.cc +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc +>> Compiling edm plugin /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/plugins/VertexBlock.cc +Entering library rule at AnalysisSpace/TreeMaker +>> Building LCG reflex dict from header file src/AnalysisSpace/TreeMaker/src/classes.h +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::vector > for ROOT: vector +Selected class -> std::map, std::vector >, std::less >, std::allocator, std::vector > > > > for ROOT: map > +Selected class -> std::map >, std::less, std::allocator > > > > for ROOT: map > +Selected class -> vhtm::Candidate for ROOT: vhtm::Candidate +Selected class -> vhtm::PackedPFCandidate for ROOT: vhtm::PackedPFCandidate +Selected class -> vhtm::Event for ROOT: vhtm::Event +Selected class -> vhtm::GenEvent for ROOT: vhtm::GenEvent +Selected class -> vhtm::Electron for ROOT: vhtm::Electron +Selected class -> vhtm::GenParticle for ROOT: vhtm::GenParticle +Selected class -> vhtm::GenJet for ROOT: vhtm::GenJet +Selected class -> vhtm::MET for ROOT: vhtm::MET +Selected class -> vhtm::Tau for ROOT: vhtm::Tau +Selected class -> vhtm::Muon for ROOT: vhtm::Muon +Selected class -> vhtm::Jet for ROOT: vhtm::Jet +Selected class -> vhtm::Vertex for ROOT: vhtm::Vertex +Selected class -> vhtm::GenMET for ROOT: vhtm::GenMET +Selected class -> vhtm::TriggerObject for ROOT: vhtm::TriggerObject +Selected class -> vhtm::Photon for ROOT: vhtm::Photon +>> Compiling LCG dictionary: tmp/slc6_amd64_gcc491/src/AnalysisSpace/TreeMaker/src/AnalysisSpaceTreeMaker/a/AnalysisSpaceTreeMaker_xr.cc +>> Compiling /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc +>> Compiling /afs/cern.ch/work/s/sroychow/public/HZZ4l/forData/Run2015D/CMSSW_7_4_14/src/AnalysisSpace/TreeMaker/src/Utility.cc +>> Compiling capabilities tmp/slc6_amd64_gcc491/src/AnalysisSpace/TreeMaker/src/AnalysisSpaceTreeMaker/a/seal_cap.cc +>> Building shared library tmp/slc6_amd64_gcc491/src/AnalysisSpace/TreeMaker/src/AnalysisSpaceTreeMaker/libAnalysisSpaceTreeMaker.so +Copying tmp/slc6_amd64_gcc491/src/AnalysisSpace/TreeMaker/src/AnalysisSpaceTreeMaker/libAnalysisSpaceTreeMaker.so to productstore area: +Leaving library rule at AnalysisSpace/TreeMaker +>> Building edm plugin tmp/slc6_amd64_gcc491/src/AnalysisSpace/TreeMaker/plugins/TreeMakerPlugins/libTreeMakerPlugins.so +Leaving library rule at src/AnalysisSpace/TreeMaker/plugins +@@@@ Running edmWriteConfigs for TreeMakerPlugins +--- Registered EDM Plugin: TreeMakerPlugins +>> Building capability library tmp/slc6_amd64_gcc491/src/AnalysisSpace/TreeMaker/src/AnalysisSpaceTreeMaker/libAnalysisSpaceTreeMakerCapabilities.so +>> Checking EDM Class Version for src/AnalysisSpace/TreeMaker/src/classes_def.xml in libAnalysisSpaceTreeMakerCapabilities.so +Error in : cannot find dictionary module AnalysisSpaceTreeMaker_xr_rdict.pcm +[?1034herror: class 'vhtm::Electron' has a different checksum for ClassVersion 1. Increment ClassVersion to 2 and assign it to checksum 1281544504 +Suggestion: You can run 'scram build updateclassversion' to generate src/AnalysisSpace/TreeMaker/src/classes_def.xml.generated with updated ClassVersion +gmake: *** [tmp/slc6_amd64_gcc491/src/AnalysisSpace/TreeMaker/src/AnalysisSpaceTreeMaker/libAnalysisSpaceTreeMakerCapabilities.so] Error 1 +gmake: *** [There are compilation/build errors. Please see the detail log above.] Error 2 diff --git a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h index bc0dfe8..187b43c 100644 --- a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h +++ b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h @@ -46,6 +46,8 @@ namespace vhtm { float dxyError; float dzError; + std::map< std::string,std::vector > isolationMap; + ClassDef(PackedPFCandidate,1) }; @@ -137,6 +139,7 @@ namespace vhtm { double scET; double scRawEnergy; float BDT; + float BDTpreComp; // Vertex association variables double dxyPV; double dzPV; @@ -172,7 +175,9 @@ namespace vhtm { int fidFlag; std::map idmap; int selbit; - + bool passMediumId; + bool passTightId; + int mvaCategory; std::map< std::string,std::vector > isolationMap; ClassDef(Electron, 1) @@ -319,6 +324,8 @@ namespace vhtm { bool isGlobalMuon; bool isTrackerMuon; bool isPFMuon; + bool isghostCleaned; + double eta; double phi; double pt; @@ -329,7 +336,8 @@ namespace vhtm { double trkD0; double trkDz; - + int muonBestTrackType; + double globalChi2; double tkNChi2; @@ -342,10 +350,14 @@ namespace vhtm { float pfPhotonIso03; float sumPUPt03; float pfRelIso03; - float pfChargedIsoR04; - float sumPUPt04; + + float sumChargedParticlePt; + float sumChargedHadronPt; + float sumNeutralHadronEt; + float sumPhotonEt; + float sumPUPt; float pfRelIso04; - + int passID; double dxyPV; double dzPV; @@ -380,6 +392,8 @@ namespace vhtm { unsigned int stationGapMaskPull; bool muonID; + + int nSegments; int selbit; std::map< std::string,std::vector > isolationMap; @@ -424,8 +438,11 @@ namespace vhtm { //double combinedSecondaryVertexMVABTag; float combinedInclusiveSecondaryVertexBTag; float combinedInclusiveSecondaryVertexV2BJetTags; + float pfCombinedInclusiveSecondaryVertexV2BJetTags; //double combinedMVABTag; std::map discrimap; + + float jpumva; int passLooseID; int passTightID; diff --git a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc index c1a661f..a1ac673 100644 --- a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.cc @@ -1,6 +1,5 @@ #include #include - #include "TFile.h" #include "TTree.h" #include "TROOT.h" @@ -13,6 +12,8 @@ #include "DataFormats/TrackReco/interface/Track.h" #include "DataFormats/TrackReco/interface/TrackFwd.h" #include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/Common/interface/ValueMap.h" +#include "DataFormats/EgammaCandidates/interface/GsfElectron.h" #include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" #include "AnalysisSpace/TreeMaker/plugins/ElectronBlock.h" @@ -22,15 +23,21 @@ ElectronBlock::ElectronBlock(const edm::ParameterSet& iConfig): verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), bsCorr_(iConfig.getUntrackedParameter("beamSpotCorr", false)), + trigMode_(iConfig.getUntrackedParameter("useTrigMode", false)), bsTag_(iConfig.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), electronTag_(iConfig.getUntrackedParameter("electronSrc", edm::InputTag("selectedPatElectrons"))), pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), - MVAidCollection_(iConfig.getParameter("MVAId")), bsToken_(consumes(bsTag_)), vertexToken_(consumes(vertexTag_)), electronToken_(consumes(electronTag_)), - pfToken_(consumes(pfcandTag_)) + pfToken_(consumes(pfcandTag_)), + eleMediumIdMapToken_(consumes >(iConfig.getParameter("eleMediumIdMap"))), + eleTightIdMapToken_(consumes >(iConfig.getParameter("eleTightIdMap"))), + mvaValuesMapToken_(consumes >(iConfig.getParameter("mvaValuesMap"))), + mvaCategoriesMapToken_(consumes >(iConfig.getParameter("mvaCategoriesMap"))), + gsfelectronTokenMVAId_(consumes >(electronTag_)), + branchName_(iConfig.getParameter("objectbranchName")) { } ElectronBlock::~ElectronBlock() { @@ -41,24 +48,11 @@ void ElectronBlock::beginJob() std::string tree_name = "vhtree"; TTree* tree = vhtm::Utility::getTree(tree_name); list_ = new std::vector(); - tree->Branch("Electron", "std::vector", &list_, 32000, 2); - tree->Branch("nElectron", &fnElectron_, "fnElectron_/I"); - //Electron MVA part - std::vector myManualCatWeigths; - myManualCatWeigths.push_back("EgammaAnalysis/ElectronTools/data/CSA14/TrigIDMVA_50ns_EB_BDT.weights.xml"); - myManualCatWeigths.push_back("EgammaAnalysis/ElectronTools/data/CSA14/TrigIDMVA_50ns_EE_BDT.weights.xml"); - vector myManualCatWeigthsTrig; - string the_path; - for (unsigned i = 0 ; i < myManualCatWeigths.size() ; i++){ - the_path = edm::FileInPath ( myManualCatWeigths[i] ).fullPath(); - myManualCatWeigthsTrig.push_back(the_path); - } - - myMVATrig = new EGammaMvaEleEstimatorCSA14(); - myMVATrig->initialize("BDT", - EGammaMvaEleEstimatorCSA14::kTrig, - true, - myManualCatWeigthsTrig); + //tree->Branch("Electron", "std::vector", &list_, 32000, -1); + //tree->Branch("nElectron", &fnElectron_, "fnElectron_/I"); + tree->Branch(branchName_.c_str(), "std::vector", &list_, 32000, -1); + std::string nobj = "n" + branchName_; + tree->Branch(nobj.c_str(), &fnElectron_, "fnElectron_/I"); } void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { // Reset the vector and the nObj variables @@ -68,9 +62,25 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe edm::Handle electrons; bool found = iEvent.getByToken(electronToken_, electrons); + edm::Handle > gsfelectrons; + iEvent.getByToken(gsfelectronTokenMVAId_, gsfelectrons); + //bool gsf_found = iEvent.getByToken(gsfelectronTokenMVAId_, gsfelectrons); + //if( gsf_found ) std::cout << "GSF Found" << std::endl; + edm::Handle pfs; iEvent.getByToken(pfToken_, pfs); + edm::Handle > medium_id_decisions; + edm::Handle > tight_id_decisions; + iEvent.getByToken(eleMediumIdMapToken_,medium_id_decisions); + iEvent.getByToken(eleTightIdMapToken_,tight_id_decisions); + + // Get MVA values and categories (optional) + edm::Handle > mvaValues; + edm::Handle > mvaCategories; + iEvent.getByToken(mvaValuesMapToken_,mvaValues); + iEvent.getByToken(mvaCategoriesMapToken_,mvaCategories); + if (found && electrons.isValid()) { edm::Handle beamSpot; if (bsCorr_) iEvent.getByToken(bsToken_, beamSpot); @@ -79,6 +89,9 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe iEvent.getByToken(vertexToken_, primaryVertices); edm::LogInfo("ElectronBlock") << "Total # PAT Electrons: " << electrons->size(); + + //auto gsfit = gsfelectrons->begin(); + unsigned int gsfeleidx = 0; for (const pat::Electron& v: *electrons) { if (list_->size() == kMaxElectron_) { edm::LogInfo("ElectronBlock") << "Too many PAT Electrons, fnElectron = " @@ -100,6 +113,15 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe float nMissingHits = 0; double dxyWrtPV = -99.; double dzWrtPV = -99.; + + //storing of ele id decisions + const auto gsfel = gsfelectrons->ptrAt(gsfeleidx); + electron.passMediumId = (*medium_id_decisions)[gsfel]; + electron.passTightId = (*tight_id_decisions)[gsfel]; + electron.BDT = (*mvaValues)[gsfel]; + gsfeleidx++; + + electron.BDTpreComp = v.userFloat("ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values"); if (hasGsfTrack) { reco::GsfTrackRef tk = v.gsfTrack(); @@ -181,8 +203,6 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe electron.scET = v.superCluster()->energy()/cosh(v.superCluster()->eta()); electron.scRawEnergy = v.superCluster()->rawEnergy(); -// electron.BDT=v.electronID("mvaNonTrigV0"); - electron.BDT = myMVATrig->mvaValue(v,false); electron.relIso = (v.trackIso() + v.ecalIso() + v.hcalIso())/v.pt(); @@ -336,7 +356,7 @@ void ElectronBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe void ElectronBlock::calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Electron& v, std::vector& iso) { // initialize sums - double charged = 0, neutral = 0, pileup = 0; +double chargedhad = 0., chargedSum = 0., neutral = 0., photon = 0., pileup = 0; // now get a list of the PF candidates used to build this lepton, so to exclude them std::vector footprint; for (unsigned int i = 0, n = v.numberOfSourceCandidatePtrs(); i < n; ++i) { @@ -351,16 +371,28 @@ void ElectronBlock::calcIsoFromPF(double cone, edm::Handle 0.5) neutral += pf.pt(); + if (pf.pt() > 0.5) { + if( pf.pdgId() == 22 ) + photon += pf.pt(); + else + neutral += pf.pt(); + } } else if (pf.fromPV() >= 2) { - charged += pf.pt(); + int pdg = std::abs(pf.pdgId()); + if( pdg!=13 && pdg!=11 ) { + chargedhad += pf.pt(); + chargedSum += pf.pt(); + } else + chargedSum += pf.pt(); } else { if (pf.pt() > 0.5) pileup += pf.pt(); } } } - iso.push_back(charged); + iso.push_back(chargedhad); + iso.push_back(chargedSum); iso.push_back(neutral); + iso.push_back(photon); iso.push_back(pileup); } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h index 214214e..69a09b9 100644 --- a/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/ElectronBlock.h @@ -21,8 +21,6 @@ #include "DataFormats/BeamSpot/interface/BeamSpot.h" #include "DataFormats/EgammaCandidates/interface/GsfElectron.h" -#include "EgammaAnalysis/ElectronTools/interface/EGammaMvaEleEstimatorCSA14.h" - namespace vhtm { class Electron; } @@ -49,18 +47,30 @@ class ElectronBlock : public edm::EDAnalyzer int verbosity_; bool bsCorr_; - - EGammaMvaEleEstimatorCSA14* myMVATrig; + bool trigMode_; const edm::InputTag bsTag_; const edm::InputTag vertexTag_; const edm::InputTag electronTag_; const edm::InputTag pfcandTag_; - const edm::InputTag MVAidCollection_; - + + const edm::EDGetTokenT bsToken_; const edm::EDGetTokenT vertexToken_; const edm::EDGetTokenT electronToken_; const edm::EDGetTokenT pfToken_; + + // ID decisions objects + edm::EDGetTokenT > eleMediumIdMapToken_; + edm::EDGetTokenT > eleTightIdMapToken_; + + // MVA values and categories (optional) + edm::EDGetTokenT > mvaValuesMapToken_; + edm::EDGetTokenT > mvaCategoriesMapToken_; + + edm::EDGetToken gsfelectronTokenMVAId_; + + std::string branchName_; + }; #endif diff --git a/AnalysisSpace/TreeMaker/plugins/EventBlock.cc b/AnalysisSpace/TreeMaker/plugins/EventBlock.cc index 5485972..2c150c3 100644 --- a/AnalysisSpace/TreeMaker/plugins/EventBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/EventBlock.cc @@ -57,7 +57,7 @@ void EventBlock::beginJob() { // Get TTree pointer TTree* tree = vhtm::Utility::getTree("vhtree"); list_ = new std::vector(); - tree->Branch("Event", "std::vector", &list_, 32000, 2); + tree->Branch("Event", "std::vector", &list_, 32000, -1); nPU_ = new std::vector(); tree->Branch("nPU", "std::vector", &nPU_); diff --git a/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc index b18fad7..42339fa 100644 --- a/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc @@ -29,7 +29,7 @@ void GenEventBlock::beginJob() TTree* tree = vhtm::Utility::getTree("vhtree"); list_ = new std::vector(); - tree->Branch("GenEvent", "std::vector", &list_, 32000, 2); + tree->Branch("GenEvent", "std::vector", &list_, 32000, -1); pdfWeights_ = new std::vector(); tree->Branch("pdfWeights", "vector", &pdfWeights_); diff --git a/AnalysisSpace/TreeMaker/plugins/GenJetBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenJetBlock.cc index a262d43..141989a 100644 --- a/AnalysisSpace/TreeMaker/plugins/GenJetBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/GenJetBlock.cc @@ -18,7 +18,7 @@ void GenJetBlock::beginJob() { // Get TTree pointer TTree* tree = vhtm::Utility::getTree("vhtree"); list_ = new std::vector(); - tree->Branch("GenJet", "std::vector", &list_, 32000, 2); + tree->Branch("GenJet", "std::vector", &list_, 32000, -1); tree->Branch("nGenJet", &fnGenJet_, "fnGenJet_/I"); } void GenJetBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { diff --git a/AnalysisSpace/TreeMaker/plugins/GenMETBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenMETBlock.cc index 6fc3dc8..e323b43 100644 --- a/AnalysisSpace/TreeMaker/plugins/GenMETBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/GenMETBlock.cc @@ -19,7 +19,7 @@ void GenMETBlock::beginJob() // Get TTree pointer TTree* tree = vhtm::Utility::getTree("vhtree"); list_ = new std::vector(); - tree->Branch("GenMET", "std::vector", &list_, 32000, 2); + tree->Branch("GenMET", "std::vector", &list_, 32000, -1); tree->Branch("nGenMET", &fnGenMET_, "fnGenMET_/I"); } void GenMETBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { diff --git a/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.cc index 7388860..64c7d51 100644 --- a/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/GenParticleBlock.cc @@ -23,7 +23,7 @@ void GenParticleBlock::beginJob() { // Get TTree pointer TTree* tree = vhtm::Utility::getTree("vhtree"); list_ = new std::vector(); - tree->Branch("GenParticle", "std::vector", &list_, 32000, 2); + tree->Branch("GenParticle", "std::vector", &list_, 32000, -1); tree->Branch("nGenParticle", &fnGenParticle_, "fnGenParticle_/I"); } void GenParticleBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { diff --git a/AnalysisSpace/TreeMaker/plugins/JetBlock.cc b/AnalysisSpace/TreeMaker/plugins/JetBlock.cc index 2d96338..787142f 100644 --- a/AnalysisSpace/TreeMaker/plugins/JetBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/JetBlock.cc @@ -26,7 +26,7 @@ void JetBlock::beginJob() std::string tree_name = "vhtree"; TTree* tree = vhtm::Utility::getTree(tree_name); list_ = new std::vector(); - tree->Branch("Jet", "std::vector", &list_, 32000, 2); + tree->Branch("Jet", "std::vector", &list_, 32000, -1); tree->Branch("nJet", &fnJet_, "fnJet_/I"); } void JetBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { @@ -91,13 +91,15 @@ void JetBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) //jobj.combinedMVABTag = jet.bDiscriminator("combinedMVABJetTags"); //added for 720 jobj.combinedInclusiveSecondaryVertexV2BJetTags = jet.bDiscriminator("combinedInclusiveSecondaryVertexV2BJetTags"); - + jobj.pfCombinedInclusiveSecondaryVertexV2BJetTags = jet.bDiscriminator("pfCombinedInclusiveSecondaryVertexV2BJetTags"); jobj.passLooseID = passjetLoose; jobj.passTightID = passjetTight; for (const std::pair& pa: jet.getPairDiscri()) jobj.discrimap[pa.first] = pa.second; + jobj.jpumva=jet.userFloat("pileupJetId:fullDiscriminant"); + list_->push_back(jobj); } fnJet_ = list_->size(); diff --git a/AnalysisSpace/TreeMaker/plugins/METBlock.cc b/AnalysisSpace/TreeMaker/plugins/METBlock.cc index 979ebdd..27a00b5 100644 --- a/AnalysisSpace/TreeMaker/plugins/METBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/METBlock.cc @@ -23,16 +23,16 @@ void METBlock::beginJob() TTree* tree = vhtm::Utility::getTree("vhtree"); pfList_ = new std::vector(); - tree->Branch("MET", "std::vector", &pfList_, 32000, 2); + tree->Branch("MET", "std::vector", &pfList_, 32000, -1); tree->Branch("nMET", &fnPFMET_, "fnPFMET_/I"); #if 0 corrList_ = new std::vector(); - tree->Branch("corrMET", "std::vector", &corrList_, 32000, 2); + tree->Branch("corrMET", "std::vector", &corrList_, 32000, -1); tree->Branch("corrnMET", &fnCorrMET_, "fnCorrMET_/I"); mvaList_ = new std::vector(); - tree->Branch("mvaMET", "std::vector", &mvaList_, 32000, 2); + tree->Branch("mvaMET", "std::vector", &mvaList_, 32000, -1); tree->Branch("mvanMET", &fnMVAMET_, "fnMVAMET_/I"); #endif } @@ -68,9 +68,14 @@ void METBlock::fillMET(const edm::Event& iEvent, mobj.met = v.pt(); mobj.metphi = v.phi(); mobj.sumet = v.sumEt(); +/* mobj.metuncorr = v.uncorrectedPt(pat::MET::uncorrALL); mobj.metphiuncorr = v.uncorrectedPhi(pat::MET::uncorrALL); mobj.sumetuncorr = v.sumEt() - v.corSumEt(pat::MET::uncorrALL); +*/ + mobj.metuncorr = v.uncorPt(); + mobj.metphiuncorr = v.uncorPhi(); + mobj.sumetuncorr = v.sumEt(); list->push_back(mobj); } diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc index 2701fbf..c508094 100644 --- a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc @@ -1,6 +1,8 @@ #include - +#include #include "TTree.h" +#include "TClass.h" +using std::setw; #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "CommonTools/UtilAlgos/interface/TFileService.h" @@ -19,6 +21,9 @@ #include "DataFormats/MuonReco/interface/MuonIsolation.h" #include "DataFormats/MuonReco/interface/MuonPFIsolation.h" +//#include "DataFormats/MuonReco/interface/Muon.h" +#include "DataFormats/MuonReco/interface/MuonSelectors.h" + #include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" #include "AnalysisSpace/TreeMaker/plugins/MuonBlock.h" #include "AnalysisSpace/TreeMaker/interface/Utility.h" @@ -34,7 +39,9 @@ MuonBlock::MuonBlock(const edm::ParameterSet& iConfig): muonToken_(consumes(muonTag_)), vertexToken_(consumes(vertexTag_)), bsToken_(consumes(bsTag_)), - pfToken_(consumes(pfcandTag_)) + pfToken_(consumes(pfcandTag_)), + defaultBestMuon_(!iConfig.existsAs("customArbitration")), + bestMuonSelector_(defaultBestMuon_ ? std::string("") : iConfig.getParameter("customArbitration")) { } MuonBlock::~MuonBlock() { @@ -44,7 +51,9 @@ void MuonBlock::beginJob() // Get TTree pointer TTree* tree = vhtm::Utility::getTree("vhtree"); list_ = new std::vector(); - tree->Branch("Muon", "std::vector", &list_, 32000, 2); +// TClass::GetClass("std::vector")->SetCanSplit(true); + tree->Branch("Muon", "std::vector", &list_, 32000, -1); + //tree->Branch("Muon", "std::vector", &list_); tree->Branch("nMuon", &fnMuon_, "fnMuon_/I"); } void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { @@ -66,16 +75,49 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) iEvent.getByToken(bsToken_, beamSpot); edm::LogInfo("MuonBlock") << "Total # of Muons: " << muons->size(); - for (const pat::Muon& v: *muons) { +//Muon Ghost cleaning + + unsigned int nMu = muons->size(); + std::vector good(nMu, true); + for( unsigned int i = 0; iat(i); + if( !mu1.track().isNonnull() ) good[i] = false; + if( !good[i] ) continue; + int nSegments1 = mu1.numberOfMatches(reco::Muon::SegmentArbitration); + for( unsigned int j = i+1; jat(j); + if ( isSameMuon(mu1,mu2) ) continue; + if( !good[j] || !mu2.track().isNonnull() ) continue; + int nSegments2 = mu2.numberOfMatches(reco::Muon::SegmentArbitration); + if (nSegments2 == 0 || nSegments1 == 0) continue; + double sf = muon::sharedSegments(mu1,mu2)/std::min(nSegments1,nSegments2); + if ( sf > 0.499 ) { + if ( isBetterMuon(mu1,mu2) ) { + good[j] = false; + } else { + good[i] = false; + + } + } + + } + } + + +// for (const pat::Muon& v: *muons) { + for ( unsigned int i = 0; i < nMu; ++i ) { if (list_->size() == kMaxMuon_) { edm::LogInfo("MuonBlock") << "Too many PAT Muons, fnMuon = " << list_->size(); break; } - + const pat::Muon& v = muons->at(i); + bool ghostCleaned = good[i] || (v.isGlobalMuon() && v.numberOfMatches() >= 2); vhtm::Muon muon; muon.isGlobalMuon = v.isGlobalMuon() ? true : false; muon.isTrackerMuon = v.isTrackerMuon() ? true : false; muon.isPFMuon = v.isPFMuon(); + + muon.isghostCleaned = ghostCleaned; muon.eta = v.eta(); muon.phi = v.phi(); @@ -84,15 +126,17 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) muon.energy = v.energy(); muon.charge = v.charge(); - bool hasTkinRef = v.innerTrack().isNonnull(); - reco::TrackRef tk; + reco::TrackRef tk = v.muonBestTrack(); + bool hasTkinRef = tk.isNonnull(); + if( hasTkinRef ) { - tk = v.innerTrack(); // tracker segment only + //tk = v.innerTrack(); // tracker segment only muon.tkNChi2 = tk->normalizedChi2(); double trkd0 = tk->d0(); double trkdz = tk->dz(); - + muon.muonBestTrackType = v.muonBestTrackType(); + if (bsCorr_) { if (beamSpot.isValid()) { trkd0 = -(tk->dxy(beamSpot->position())); @@ -120,15 +164,18 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) const reco::Vertex& vit = primaryVertices->front(); // Highest sumPt vertex - +/* if( hasTkinRef ) { dxyWrtPV = tk->dxy(vit.position()); dzWrtPV = tk->dz(vit.position()); } +*/ + dxyWrtPV = tk->dxy(vit.position()); + dzWrtPV = tk->dz(vit.position()); + muon.dxyPV = dxyWrtPV; muon.dzPV = dzWrtPV; - // Vertex association double minVtxDist3D = 9999.; int indexVtx = -1; @@ -160,10 +207,11 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) // Hit pattern if( hasTkinRef ) { - bool hasTkgRef = v.globalTrack().isNonnull(); + //bool hasTkgRef = v.globalTrack().isNonnull(); //if( hasTkgRef ) // reco::TrackRef gtk = v.globalTrack(); - const reco::HitPattern& hitp = hasTkgRef ? v.globalTrack()->hitPattern() : tk->hitPattern(); // innerTrack will not provide Muon Hits + //const reco::HitPattern& hitp = hasTkgRef ? v.globalTrack()->hitPattern() : tk->hitPattern(); // innerTrack will not provide Muon Hits + const reco::HitPattern& hitp = tk->hitPattern(); // innerTrack will not provide Muon Hits muon.pixHits = hitp.numberOfValidPixelHits(); muon.trkHits = hitp.numberOfValidTrackerHits(); muon.muoHits = hitp.numberOfValidMuonHits(); @@ -194,9 +242,14 @@ void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) muon.pfRelIso03 = iso; const reco::MuonPFIsolation& pfIso04 = v.pfIsolationR04(); - muon.pfChargedIsoR04 = pfIso04.sumChargedParticlePt; - muon.sumPUPt04 = pfIso04.sumPUPt; - absiso = pfIso04.sumChargedParticlePt + std::max(0.0, pfIso04.sumNeutralHadronEt + pfIso04.sumPhotonEt - 0.5 * pfIso04.sumPUPt); + muon.sumChargedParticlePt = pfIso04.sumChargedParticlePt; + muon.sumChargedHadronPt = pfIso04.sumChargedHadronPt; + muon.sumNeutralHadronEt = pfIso04.sumNeutralHadronEt; + muon.sumPhotonEt = pfIso04.sumPhotonEt; + muon.sumPUPt = pfIso04.sumPUPt; + // std::cout<<"Muonblock="<push_back(muon); } fnMuon_ = list_->size(); + if(verbosity_) { + int indx = 0; + + std::cout << "\n Printing Muon Collection Information for event \n "; + + std::cout << std::fixed << std::setprecision(3); + std::cout << " indx pT eta phi charge dxy dz global tracker PF nMatch Type SIP ghostCleaned reliso" + << std::endl; + for (auto const& muon: *list_ ) { + double iso = muon.sumChargedHadronPt + std::max(0., muon.sumNeutralHadronEt + muon.sumPhotonEt - 0.5 * muon.sumPUPt); + std::cout << setw(6) << ++indx + << setw(8) << muon.pt + << setw(8) << muon.eta + << setw(8) << muon.phi + << setw(8) << muon.charge + << setw(8) << muon.dxyPV + << setw(8) << muon.dzPV + << setw(8) << muon.isGlobalMuon + << setw(8) << muon.isTrackerMuon + << setw(8) << muon.isPFMuon + << setw(8) << muon.matches + << setw(6) << muon.muonBestTrackType + << setw(10) << muon.dB3D/muon.edB3D + << setw(13) << muon.isghostCleaned + << setw(8) << iso/muon.pt + << std::endl; + } + } } else { edm::LogError("MuonBlock") << "Error >> Failed to get pat::Muon collection for label: " << muonTag_; } + } void MuonBlock::calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Muon& v, std::vector& iso) { // initialize sums - double charged = 0, neutral = 0, pileup = 0; + double chargedhad = 0., chargedSum = 0., neutral = 0., photon = 0., pileup = 0; // now get a list of the PF candidates used to build this lepton, so to exclude them std::vector footprint; + std::vector< std::pair > chargedhadPdgPt,chargedSumPdgPt,neutralPdgPt,photonPdgPt,pileupPdgPt; for (unsigned int i = 0, n = v.numberOfSourceCandidatePtrs(); i < n; ++i) { footprint.push_back(v.sourceCandidatePtr(i)); } @@ -303,17 +387,91 @@ void MuonBlock::calcIsoFromPF(double cone, edm::Handle 0.5) neutral += pf.pt(); + if (pf.pt() > 0.5) { + if( pf.pdgId() == 22 ) { + photon += pf.pt(); + photonPdgPt.push_back(std::make_pair( pf.pdgId(),pf.pt() )); + } + else { + neutral += pf.pt(); + neutralPdgPt.push_back(std::make_pair( pf.pdgId(),pf.pt() )); + } + } } else if (pf.fromPV() >= 2) { - charged += pf.pt(); + int pdg = std::abs(pf.pdgId()); + if( pdg!=13 && pdg!=11 ) { + chargedhad += pf.pt(); + chargedSum += pf.pt(); + chargedhadPdgPt.push_back(std::make_pair( pf.pdgId(),pf.pt() )); + chargedSumPdgPt.push_back(std::make_pair( pf.pdgId(),pf.pt() )); + } else { + chargedSum += pf.pt(); + chargedSumPdgPt.push_back(std::make_pair( pf.pdgId(),pf.pt() )); + } } else { - if (pf.pt() > 0.5) pileup += pf.pt(); + if (pf.pt() > 0.5) { + pileup += pf.pt(); + pileupPdgPt.push_back(std::make_pair( pf.pdgId(),pf.pt() )); + } } } } - iso.push_back(charged); + iso.push_back(chargedhad); + iso.push_back(chargedSum); iso.push_back(neutral); + iso.push_back(photon); iso.push_back(pileup); + if(verbosity_) { + if( cone==0.3 ) { + std::cout<<"Infomation of PackedPFCandidate Isolation Calculation" <ptError()/mu1.track()->pt() < mu2.track()->ptError()/mu2.track()->pt(); + } else { + int nm1 = mu1.numberOfMatches(reco::Muon::SegmentArbitration); + int nm2 = mu2.numberOfMatches(reco::Muon::SegmentArbitration); + return (nm1 != nm2 ? nm1 > nm2 : mu1.pt() > mu2.pt()); + } +} + #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(MuonBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc.saved b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc.saved new file mode 100644 index 0000000..0f738b9 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.cc.saved @@ -0,0 +1,337 @@ +#include + +#include "TTree.h" + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include "DataFormats/PatCandidates/interface/Muon.h" +#include "DataFormats/TrackReco/interface/HitPattern.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "Math/GenVector/VectorUtil.h" +#include "DataFormats/Math/interface/deltaR.h" + +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" +#include "DataFormats/GeometryVector/interface/VectorUtil.h" + +#include "DataFormats/MuonReco/interface/MuonIsolation.h" +#include "DataFormats/MuonReco/interface/MuonPFIsolation.h" + +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" +#include "AnalysisSpace/TreeMaker/plugins/MuonBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" + +MuonBlock::MuonBlock(const edm::ParameterSet& iConfig): + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + muonTag_(iConfig.getUntrackedParameter("muonSrc", edm::InputTag("selectedPatMuons"))), + vertexTag_(iConfig.getUntrackedParameter("vertexSrc", edm::InputTag("goodOfflinePrimaryVertices"))), + bsTag_(iConfig.getUntrackedParameter("offlineBeamSpot", edm::InputTag("offlineBeamSpot"))), + pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), + bsCorr_(iConfig.getUntrackedParameter("beamSpotCorr", true)), + muonID_(iConfig.getUntrackedParameter("muonID", "GlobalMuonPromptTight")), + muonToken_(consumes(muonTag_)), + vertexToken_(consumes(vertexTag_)), + bsToken_(consumes(bsTag_)), + pfToken_(consumes(pfcandTag_)) +{ +} +MuonBlock::~MuonBlock() { +} +void MuonBlock::beginJob() +{ + // Get TTree pointer + TTree* tree = vhtm::Utility::getTree("vhtree"); + list_ = new std::vector(); + tree->Branch("Muon", "std::vector", &list_, 32000, 2); + tree->Branch("nMuon", &fnMuon_, "fnMuon_/I"); +} +void MuonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnMuon_ = 0; + + edm::Handle muons; + bool found = iEvent.getByToken(muonToken_, muons); + + edm::Handle pfs; + iEvent.getByToken(pfToken_, pfs); + + if (found && muons.isValid()) { + edm::Handle primaryVertices; + iEvent.getByToken(vertexToken_, primaryVertices); + + edm::Handle beamSpot; + iEvent.getByToken(bsToken_, beamSpot); + + edm::LogInfo("MuonBlock") << "Total # of Muons: " << muons->size(); + for (const pat::Muon& v: *muons) { + if (list_->size() == kMaxMuon_) { + edm::LogInfo("MuonBlock") << "Too many PAT Muons, fnMuon = " << list_->size(); + break; + } + + vhtm::Muon muon; + muon.isGlobalMuon = v.isGlobalMuon() ? true : false; + muon.isTrackerMuon = v.isTrackerMuon() ? true : false; + muon.isPFMuon = v.isPFMuon(); + + muon.eta = v.eta(); + muon.phi = v.phi(); + muon.pt = v.pt(); + muon.p = v.p(); + muon.energy = v.energy(); + muon.charge = v.charge(); + + bool hasTkinRef = v.innerTrack().isNonnull(); + + reco::TrackRef tk; + if( hasTkinRef ) { + tk = v.innerTrack(); // tracker segment only + muon.tkNChi2 = tk->normalizedChi2(); + double trkd0 = tk->d0(); + double trkdz = tk->dz(); + + if (bsCorr_) { + if (beamSpot.isValid()) { + trkd0 = -(tk->dxy(beamSpot->position())); + trkdz = tk->dz(beamSpot->position()); + } + else + edm::LogError("MuonsBlock") << "Error >> Failed to get reco::BeamSpot for label: " + << bsTag_; + } + + muon.trkD0 = trkd0; + muon.trkDz = trkdz; + } + + + muon.globalChi2 = v.isGlobalMuon() ? v.normChi2() : 9999.; + + muon.passID = v.muonID(muonID_) ? true : false; + + + double dxyWrtPV = -99.; + double dzWrtPV = -99.; + if (primaryVertices.isValid()) { + edm::LogInfo("MuonBlock") << "Total # Primary Vertices: " << primaryVertices->size(); + + const reco::Vertex& vit = primaryVertices->front(); // Highest sumPt vertex + + + if( hasTkinRef ) { + dxyWrtPV = tk->dxy(vit.position()); + dzWrtPV = tk->dz(vit.position()); + } + muon.dxyPV = dxyWrtPV; + muon.dzPV = dzWrtPV; + + + // Vertex association + double minVtxDist3D = 9999.; + int indexVtx = -1; + double vertexDistZ = 9999.; + for (auto vit = primaryVertices->begin(); vit != primaryVertices->end(); ++vit) { + + double dxy = 9999.; + double dz = 9999.; + if( hasTkinRef ) { + dxy = tk->dxy(vit->position()); + dz = tk->dz(vit->position()); + double dist3D = std::sqrt(pow(dxy,2) + pow(dz,2)); + if (dist3D < minVtxDist3D) { + minVtxDist3D = dist3D; + indexVtx = static_cast(std::distance(primaryVertices->begin(), vit)); + vertexDistZ = dz; + } + } + } + + muon.vtxDist3D = minVtxDist3D; + muon.vtxIndex = indexVtx; + muon.vtxDistZ = vertexDistZ; + } + else { + edm::LogError("MuonBlock") << "Error >> Failed to get reco::VertexCollection for label: " + << vertexTag_; + } + + // Hit pattern + if( hasTkinRef ) { + bool hasTkgRef = v.globalTrack().isNonnull(); + //if( hasTkgRef ) + // reco::TrackRef gtk = v.globalTrack(); + const reco::HitPattern& hitp = hasTkgRef ? v.globalTrack()->hitPattern() : tk->hitPattern(); // innerTrack will not provide Muon Hits + muon.pixHits = hitp.numberOfValidPixelHits(); + muon.trkHits = hitp.numberOfValidTrackerHits(); + muon.muoHits = hitp.numberOfValidMuonHits(); + muon.matches = v.numberOfMatches(); + muon.trackerLayersWithMeasurement = hitp.trackerLayersWithMeasurement(); + } + + int numMuonStations = 0; + unsigned int stationMask = static_cast(v.stationMask(reco::Muon::SegmentAndTrackArbitration)); + for (int i = 0; i < 8; ++i) // eight stations, eight bits + if (stationMask & (1<normalizedChi2(); + // double ptError = v.innerTrack()->ptError()/v.innerTrack()->pt(); + double ptError = 0.05,normalizeChi2 = 5; + bool muonID = v.isGlobalMuon() && + v.isTrackerMuon() && + muon.isGlobalMuonPromptTight && + muon.isAllArbitrated && + std::fabs(dxyWrtPV) < 0.02 && + std::fabs(dzWrtPV) < 0.2 && + normalizeChi2 < 10 && + ptError < 0.1 && + muon.trkHits >= 10 && + muon.pixHits >= 1 && + numMuonStations >= 2 && + muon.nMatches >= 1; + muon.muonID = muonID; + + // Vertex information + const reco::Candidate::Point& vertex = v.vertex(); + muon.vx = vertex.x(); + muon.vy = vertex.y(); + muon.vz = vertex.z(); + + + //Isolation from packed PF candidates + + std::vector isotemp; +// for( double cone=0.15;cone<=0.45;cone+=0.05){ +// isotemp.clear(); +// calcIsoFromPF(cone, pfs, v, isotemp); +// muon.isolationMap[cone] = isotemp; +// } + calcIsoFromPF(0.15, pfs, v, isotemp); + muon.isolationMap["c15"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.20, pfs, v, isotemp); + muon.isolationMap["c20"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.25, pfs, v, isotemp); + muon.isolationMap["c25"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.30, pfs, v, isotemp); + muon.isolationMap["c30"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.35, pfs, v, isotemp); + muon.isolationMap["c35"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.40, pfs, v, isotemp); + muon.isolationMap["c40"] = isotemp; + + isotemp.clear(); + calcIsoFromPF(0.45, pfs, v, isotemp); + muon.isolationMap["c45"] = isotemp; + + muon.nSegments = v.numberOfMatches(reco::Muon::SegmentArbitration); + list_->push_back(muon); + } + fnMuon_ = list_->size(); + } + else { + edm::LogError("MuonBlock") << "Error >> Failed to get pat::Muon collection for label: " + << muonTag_; + } +} + +void MuonBlock::calcIsoFromPF(double cone, edm::Handle& pfs, const pat::Muon& v, std::vector& iso) +{ + // initialize sums + double chargedhad = 0., chargedSum = 0., neutral = 0., photon = 0., pileup = 0; + // now get a list of the PF candidates used to build this lepton, so to exclude them + std::vector footprint; + for (unsigned int i = 0, n = v.numberOfSourceCandidatePtrs(); i < n; ++i) { + footprint.push_back(v.sourceCandidatePtr(i)); + } + // now loop on pf candidates + for (unsigned int i = 0, n = pfs->size(); i < n; ++i) { + const pat::PackedCandidate &pf = (*pfs)[i]; + if (deltaR(pf,v) < cone) { + //pfcandidate-based footprint removal + if (std::find(footprint.begin(), footprint.end(), reco::CandidatePtr(pfs,i)) != footprint.end()) { + continue; + } + if (pf.charge() == 0) { + if (pf.pt() > 0.5) { + if( pf.pdgId() == 22 ) + photon += pf.pt(); + else + neutral += pf.pt(); + } + } else if (pf.fromPV() >= 2) { + int pdg = std::abs(pf.pdgId()); + if( pdg!=13 && pdg!=11 ) { + chargedhad += pf.pt(); + chargedSum += pf.pt(); + } else + chargedSum += pf.pt(); + } else { + if (pf.pt() > 0.5) pileup += pf.pt(); + } + } + } + iso.push_back(chargedhad); + iso.push_back(chargedSum); + iso.push_back(neutral); + iso.push_back(photon); + iso.push_back(pileup); +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(MuonBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/MuonBlock.h b/AnalysisSpace/TreeMaker/plugins/MuonBlock.h index 7b4743f..8030952 100644 --- a/AnalysisSpace/TreeMaker/plugins/MuonBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/MuonBlock.h @@ -9,6 +9,7 @@ #include "FWCore/Framework/interface/Event.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "FWCore/ServiceRegistry/interface/Service.h" +#include "CommonTools/Utils/interface/StringCutObjectSelector.h" namespace vhtm { class Muon; @@ -47,5 +48,15 @@ class MuonBlock : public edm::EDAnalyzer const edm::EDGetTokenT vertexToken_; const edm::EDGetTokenT bsToken_; const edm::EDGetTokenT pfToken_; + + + /// Use default criteria to choose the best muon + bool defaultBestMuon_; + /// Cut on the pair of objects together + typedef std::pair MuonPointerPair; + StringCutObjectSelector bestMuonSelector_; + + bool isSameMuon(const pat::Muon &mu1, const pat::Muon &mu2) const; + bool isBetterMuon(const pat::Muon &mu1, const pat::Muon &mu2) const; }; #endif diff --git a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc index 09c3068..7b068ec 100644 --- a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.cc @@ -11,13 +11,14 @@ #include "FWCore/Framework/interface/ESHandle.h" #include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "DataFormats/Math/interface/deltaR.h" #include "AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h" #include "AnalysisSpace/TreeMaker/interface/Utility.h" // Constructor PackedPFCandidateBlock::PackedPFCandidateBlock(const edm::ParameterSet& iConfig) : verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), - pfcandTag_(iConfig.getUntrackedParameter("pfCands",edm::InputTag("packedPFCandidates"))), + pfcandTag_(iConfig.getUntrackedParameter("pfCands", edm::InputTag("packedPFCandidates"))), pdgTosave_(iConfig.getParameter>("pdgTosave")), pfToken_(consumes(pfcandTag_)) {} @@ -27,34 +28,29 @@ void PackedPFCandidateBlock::beginJob() std::string tree_name = "vhtree"; TTree* tree = vhtm::Utility::getTree(tree_name); list_ = new std::vector(); - tree->Branch("PackedPFCandidate", "std::vector", &list_, 32000, 2); + tree->Branch("PackedPFCandidate", "std::vector", &list_, 32000, -1); tree->Branch("nPackedPFCandidate", &fnPackedPFCandidate_, "fnPackedPFCandidate_/I"); } void PackedPFCandidateBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { - // Reset the TClonesArray and the nObj variables + // Reset the vector and the nObj variables list_->clear(); fnPackedPFCandidate_ = 0; edm::Handle pfs; iEvent.getByToken(pfToken_, pfs); - - if ( pfs.isValid()) { + if (pfs.isValid()) { edm::LogInfo("PackedPFCandidateBlock") << "Total # PackedPFCandidate: " << pfs->size(); for (pat::PackedCandidate const& v: *pfs) { - //if (list_->size() == kMaxPhoton) { - // edm::LogInfo("PackedPFCandidate") << "Too many PAT Photon, fnPhoton = " - // << fnPhoton_; - // break; - //} - + if (list_->size() == kMaxPackedPFCandidate) { + edm::LogInfo("PackedPFCandidateBlock") << "Too many PackedPFCandidates, fnPackedPFCandidate = " + << fnPackedPFCandidate_; + break; + } + int pdg = std::abs(v.pdgId()); - if( std::find(pdgTosave_.begin(), pdgTosave_.end(), pdg) == pdgTosave_.end() ) continue; + if (std::find(pdgTosave_.begin(), pdgTosave_.end(), pdg) == pdgTosave_.end() || v.pt() <= 2.) continue; - //if( pdg != std::abs(11) && pdg != std::abs(13) && - // pdg != std::abs(15) && pdg != std::abs(22) - // ) continue; - vhtm::PackedPFCandidate pfCand; pfCand.pt = v.pt(); @@ -64,26 +60,85 @@ void PackedPFCandidateBlock::analyze(const edm::Event& iEvent, const edm::EventS pfCand.pdgId = v.pdgId(); pfCand.charge = v.charge(); - + pfCand.vx = v.vx(); pfCand.vz = v.vz(); pfCand.vz = v.vz(); - + pfCand.fromPV = v.fromPV(); pfCand.dxy = v.dxy(); pfCand.dz = v.dz(); pfCand.dxyError = v.dxyError(); pfCand.dzError = v.dzError(); - + + std::vector isotemp; + calcIsoFromPF(v, pfs, 0.30, isotemp); + pfCand.isolationMap["c30"] = isotemp; + list_->push_back(pfCand); } fnPackedPFCandidate_ = list_->size(); } else { - edm::LogError("PackedPFCandidateBlock") << "Error >> Failed to get pat::Photon for label: " - << pfcandTag_; + edm::LogError("PackedPFCandidateBlock") << "Error >> Failed to get pat::PackedPFCandidate for label: " + << pfcandTag_; } } +void PackedPFCandidateBlock::calcIsoFromPF(const pat::PackedCandidate& v, + edm::Handle& pfs, + double cone, std::vector& iso) +{ + // initialize sums + double chargedHadSum = 0., + chargedParticleSum = 0., + neutralSum = 0., + photonSum = 0., + pileupSum = 0; + + // now get a list of the PF candidates used to build this lepton, so to exclude them + std::vector footprint; + for (unsigned int i = 0; i < v.numberOfSourceCandidatePtrs(); ++i) + footprint.push_back(v.sourceCandidatePtr(i)); + + // now loop on pf candidates + for (unsigned int i = 0; i < pfs->size(); ++i) { + const pat::PackedCandidate& pf = (*pfs)[i]; + double dRcone = deltaR(v, pf); + if (dRcone < cone) { + // pfcandidate-based footprint removal + if (std::find(footprint.begin(), footprint.end(), reco::CandidatePtr(pfs, i)) != footprint.end()) continue; + + double pt = pf.pt(); + int pdg = std::abs(pf.pdgId()); + if (pf.charge() == 0) { + if (pt > 0.5 && dRcone > 0.01) { + if (pdg == 22) + photonSum += pt; + else + neutralSum += pt; + } + } + else { + if (pt > 0.2 && dRcone > 0.0001) { + if (pf.fromPV() >= 2) { + chargedParticleSum += pt; + if (pdg != 13 && pdg != 11) chargedHadSum += pt; + } + else + pileupSum += pt; + } + } + } + } + if (verbosity_) std::cout << "isoValues: (" << chargedHadSum << "," + << neutralSum << "," << photonSum << "," + << pileupSum << ")" + << std::endl; + iso.push_back(chargedHadSum); + iso.push_back(chargedParticleSum); + iso.push_back(neutralSum); + iso.push_back(photonSum); + iso.push_back(pileupSum); +} #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(PackedPFCandidateBlock); - diff --git a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h index d58b468..d3e5dc9 100644 --- a/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/PackedPFCandidateBlock.h @@ -22,30 +22,27 @@ namespace vhtm { class PackedPFCandidate; } -class PackedPFCandidateBlock : public edm::EDAnalyzer -{ +class PackedPFCandidateBlock : public edm::EDAnalyzer { private: virtual void beginJob(); virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); virtual void endJob() {} - + void calcIsoFromPF(const pat::PackedCandidate& v, edm::Handle& pfs, double cone, std::vector& iso); public: explicit PackedPFCandidateBlock(const edm::ParameterSet& iConfig); virtual ~PackedPFCandidateBlock() {} - + enum { - kMaxPackedPFCandidate = 100 + kMaxPackedPFCandidate = 250 }; private: std::vector* list_; int fnPackedPFCandidate_; - + int verbosity_; const edm::InputTag pfcandTag_; - std::vector pdgTosave_; - const edm::EDGetTokenT pfToken_; }; #endif diff --git a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc index 048e600..5585a82 100644 --- a/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/PhotonBlock.cc @@ -32,7 +32,7 @@ void PhotonBlock::beginJob() std::string tree_name = "vhtree"; TTree* tree = vhtm::Utility::getTree(tree_name); list_ = new std::vector(); - tree->Branch("Photon", "std::vector", &list_, 32000, 2); + tree->Branch("Photon", "std::vector", &list_, 32000, -1); tree->Branch("nPhoton", &fnPhoton_, "fnPhoton_/I"); } void PhotonBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { diff --git a/AnalysisSpace/TreeMaker/plugins/TauBlock.cc b/AnalysisSpace/TreeMaker/plugins/TauBlock.cc index 59ee1ba..a5873c9 100644 --- a/AnalysisSpace/TreeMaker/plugins/TauBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/TauBlock.cc @@ -38,7 +38,7 @@ void TauBlock::beginJob() // Get TTree pointer TTree* tree = vhtm::Utility::getTree("vhtree"); list_ = new std::vector(); - tree->Branch("Tau", "std::vector", &list_, 32000, 2); + tree->Branch("Tau", "std::vector", &list_, 32000, -1); tree->Branch("nTau", &fnTau_, "fnTau_/I"); } void TauBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc b/AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc index f5ba168..49caa97 100644 --- a/AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/TriggerBlock.cc @@ -19,11 +19,9 @@ TriggerBlock::TriggerBlock(const edm::ParameterSet& iConfig) : verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), l1Tag_(iConfig.getUntrackedParameter("l1InputTag", edm::InputTag("gtDigis"))), hltTag_(iConfig.getUntrackedParameter("hltInputTag", edm::InputTag("TriggerResults","","HLT"))), - prescaleTag_(iConfig.getUntrackedParameter("prescaleInputTag", edm::InputTag("patTrigger"))), hltPathsOfInterest_(iConfig.getParameter >("hltPathsOfInterest")), l1Token_(consumes(l1Tag_)), - hltToken_(consumes(hltTag_)), - prescaleToken_(consumes(prescaleTag_)) + hltToken_(consumes(hltTag_)) { } TriggerBlock::~TriggerBlock() { @@ -53,6 +51,32 @@ void TriggerBlock::beginJob() hltprescales_ = new std::vector(); tree->Branch("hltprescales", "vector", &hltprescales_); } +void TriggerBlock::beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) { + bool changed = true; + if (hltConfig_.init(iRun, iSetup, hltTag_.process(), changed)) { + // if init returns TRUE, initialisation has succeeded! + edm::LogInfo("TriggerBlock") << "HLT config with process name " + << hltTag_.process() << " successfully extracted"; + matchedPathList_.clear(); + const std::vector& pathList = hltConfig_.triggerNames(); + for (const std::string& path: pathList) { + if (hltPathsOfInterest_.size()) { + int nmatch = 0; + for (const std::string& kt: hltPathsOfInterest_) + nmatch += TPRegexp(kt).Match(path); + if (!nmatch) continue; + } + matchedPathList_.push_back(path); + } + } + else { + // if init returns FALSE, initialisation has NOT succeeded, which indicates a problem + // with the file and/or code and needs to be investigated! + edm::LogError("TriggerBlock") << "Error! HLT config extraction with process name " + << hltTag_.process() << " failed"; + // In this case, all access methods will return empty values! + } +} void TriggerBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { // Reset the vectors l1physbits_->clear(); @@ -81,24 +105,57 @@ void TriggerBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSet found = iEvent.getByToken(hltToken_, triggerResults); if (found && triggerResults.isValid()) { edm::LogInfo("TriggerBlock") << "Successfully obtained " << hltTag_; + for (auto path: matchedPathList_) { + hltpaths_->push_back(path); - edm::Handle triggerPrescales; - iEvent.getByToken(prescaleToken_, triggerPrescales); + int fired = -1; + unsigned int index = hltConfig_.triggerIndex(path); + if (index < triggerResults->size()) { + fired = (triggerResults->accept(index)) ? 1 : 0; + } + else { + edm::LogInfo("TriggerBlock") << "Requested HLT path \"" << path << "\" does not exist"; + } + hltresults_->push_back(fired); - const edm::TriggerNames &names = iEvent.triggerNames(*triggerResults); - for (unsigned int i = 0; i < triggerResults->size(); ++i) { - std::string path = names.triggerName(i); - if (hltPathsOfInterest_.size()) { - int nmatch = 0; - for (auto kt: hltPathsOfInterest_) { - nmatch += TPRegexp(kt).Match(path); - } - if (!nmatch) continue; + int prescale = -1; + if (hltConfig_.prescaleSet(iEvent, iSetup) < 0) { + edm::LogError("TriggerBlock") << "The prescale set index number could not be obtained for HLT path: " + << path; } - hltpaths_->push_back(path); - hltprescales_->push_back(triggerPrescales->getPrescaleForIndex(i)); - hltresults_->push_back((triggerResults->accept(i) ? 1 : 0)); - } + else { + prescale = hltConfig_.prescaleValue(iEvent, iSetup, path); + } + hltprescales_->push_back(prescale); + + if (verbosity_) { + + auto a = hltConfig_.prescaleValues(iEvent, iSetup, path); + + edm::LogInfo("TriggerBlock") + << ">>> Path: " << (path) + << ", prescale: " << prescale + << ", fired: " << fired + << ", PrescaleValues L1: " << a.first + << ", PrescaleValues HLT: " << a.second; + + auto d = hltConfig_.moduleLabels(path); + for (auto v: d) + edm::LogInfo("TriggerBlock") << "\tModule Labels: " << v; + } + } + if (verbosity_) { + const std::vector& b = hltConfig_.prescaleLabels(); + for (auto v: b) + edm::LogInfo("TriggerBlock") << "\tPrescale Labels: " << v; + + const std::map >& c = hltConfig_.prescaleTable(); + for (auto ptr: c) { + edm::LogInfo("TriggerBlock") << "Key : " << ptr.first << ": "; + for (auto v: ptr.second) + edm::LogInfo("TriggerBlock") << "value: " << v; + } + } } else { edm::LogError("TriggerBlock") << "Failed to get TriggerResults for label: " diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerBlock.h b/AnalysisSpace/TreeMaker/plugins/TriggerBlock.h index fc69e42..f31447e 100644 --- a/AnalysisSpace/TreeMaker/plugins/TriggerBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/TriggerBlock.h @@ -15,15 +15,14 @@ #include "DataFormats/Common/interface/Handle.h" #include "DataFormats/Provenance/interface/EventID.h" #include "FWCore/ParameterSet/interface/ProcessDesc.h" -#include "DataFormats/PatCandidates/interface/PackedTriggerPrescales.h" +#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h" class TriggerBlock: public edm::EDAnalyzer { private: - virtual void beginJob(); - virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} - virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); - virtual void endJob() {} + virtual void beginJob() override; + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) override; + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) override; public: explicit TriggerBlock(const edm::ParameterSet& iConfig); @@ -35,8 +34,9 @@ class TriggerBlock: public edm::EDAnalyzer const edm::InputTag l1Tag_; const edm::InputTag hltTag_; - const edm::InputTag prescaleTag_; const std::vector hltPathsOfInterest_; + std::vector matchedPathList_; + HLTConfigProvider hltConfig_; std::vector* l1physbits_; std::vector* l1techbits_; @@ -46,6 +46,5 @@ class TriggerBlock: public edm::EDAnalyzer const edm::EDGetTokenT l1Token_; const edm::EDGetTokenT hltToken_; - const edm::EDGetTokenT prescaleToken_; }; #endif diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc index 00c48aa..acedce7 100644 --- a/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.cc @@ -17,38 +17,47 @@ // Constructor TriggerObjectBlock::TriggerObjectBlock(const edm::ParameterSet& iConfig) : verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), - hltPathsOfInterest_(iConfig.getParameter >("hltPathsOfInterest")), - hltPattern_(iConfig.getParameter("hltPattern")), minTrigObjPt_(iConfig.getUntrackedParameter("minTrigObjPt", 5.0)), hltTag_(iConfig.getUntrackedParameter("hltInputTag", edm::InputTag("TriggerResults","","HLT"))), objectTag_(iConfig.getUntrackedParameter("triggerObjectTag", edm::InputTag("selectedPatTrigger"))), hltToken_(consumes(hltTag_)), objectToken_(consumes(objectTag_)) { - std::cout << "hltPattern = " << std::endl - << hltPattern_ - << std::endl; - re_ = new TPMERegexp(hltPattern_, "xo"); } TriggerObjectBlock::~TriggerObjectBlock() { - if (re_) delete re_; } void TriggerObjectBlock::beginJob() { std::string tree_name = "vhtree"; TTree* tree = vhtm::Utility::getTree(tree_name); list_ = new std::vector(); - tree->Branch("TriggerObject", "std::vector", &list_, 32000, 2); + tree->Branch("TriggerObject", "std::vector", &list_, 32000, -1); tree->Branch("nTriggerObject", &fnTriggerObject_, "fnTriggerObject_/I"); } +void TriggerObjectBlock::beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) { + bool changed = true; + if (hltConfig_.init(iRun, iSetup, hltTag_.process(), changed)) { + // if init returns TRUE, initialisation has succeeded! + edm::LogInfo("TriggerObjectBlock") << "HLT config with process name " + << hltTag_.process() + << " successfully extracted"; + } + else { + // if init returns FALSE, initialisation has NOT succeeded, which indicates a problem + // with the file and/or code and needs to be investigated! + edm::LogError("TriggerObjectBlock") << "Error! HLT config extraction with process name " + << hltTag_.process() << " failed"; + // In this case, all access methods will return empty values! + } +} void TriggerObjectBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { // Reset the vector and the nObj variables list_->clear(); fnTriggerObject_ = 0; - if (verbosity_) { - std::cout << setiosflags(std::ios::fixed); - std::cout << "Indx Eta Phi Pt Energy =Trigger path list=" << std::endl; + if (verbosity_ > 1) { + edm::LogInfo("TriggerObjectBlock") << setiosflags(std::ios::fixed); + edm::LogInfo("TriggerObjectBlock") << "Indx Eta Phi Pt Energy =Trigger path list="; } edm::Handle triggerBits; @@ -57,18 +66,23 @@ void TriggerObjectBlock::analyze(const edm::Event& iEvent, const edm::EventSetup edm::Handle triggerObjects; found = iEvent.getByToken(objectToken_, triggerObjects); if (found && triggerObjects.isValid()) { - // Find the triggerNames and the matched paths + // Find the triggerNames const edm::TriggerNames& names = iEvent.triggerNames(*triggerBits); - for (const std::string& v: names.triggerNames()) - if (re_->Match(v)) matchedPathList_.push_back(v); for (pat::TriggerObjectStandAlone obj: *triggerObjects) { + if (list_->size() == kMaxTriggerObject_) { + edm::LogInfo("TriggerObjectBlock") << "Too many Trigger Objects (HLT), fnTriggerObject = " + << list_->size(); + break; + } if (obj.pt() < minTrigObjPt_) continue; obj.unpackPathNames(names); + + if (verbosity_) TriggerObjectBlock::printObjectInfo(obj); std::map pathInfoMap; - for (const std::string& v: matchedPathList_) { - int val = -1; + for (const std::string& v: obj.pathNames(false)) { + int val = -1; if (obj.hasPathName(v, true, true)) val = 3; else if (obj.hasPathName(v, false, true)) val = 2; else if (obj.hasPathName(v, true, false)) val = 1; @@ -76,42 +90,70 @@ void TriggerObjectBlock::analyze(const edm::Event& iEvent, const edm::EventSetup if (val > -1) pathInfoMap.insert(std::pair(v, val)); } - if (list_->size() == kMaxTriggerObject_) { - edm::LogInfo("TriggerObjectBlock") << "Too many Trigger Muons (HLT), fnTriggerObject = " - << list_->size(); - break; - } vhtm::TriggerObject _tobj; _tobj.eta = obj.eta(); _tobj.phi = obj.phi(); _tobj.pt = obj.pt(); _tobj.energy = obj.energy(); _tobj.pathList = pathInfoMap; + list_->push_back(_tobj); - if (verbosity_) { - std::cout << std::setprecision(2); - std::cout << std::setw(4) << fnTriggerObject_++ - << std::setw(8) << _tobj.eta - << std::setw(8) << _tobj.phi - << std::setw(8) << _tobj.pt - << std::setw(8) << _tobj.energy - << std::endl; + if (verbosity_ > 1) { + edm::LogInfo("TriggerObjectBlock") << std::setprecision(2); + edm::LogInfo("TriggerObjectBlock") << std::setw(4) << list_->size() + << std::setw(8) << _tobj.eta + << std::setw(8) << _tobj.phi + << std::setw(8) << _tobj.pt + << std::setw(8) << _tobj.energy; for (auto jt: _tobj.pathList) - std::cout << "\t\t\t\t\t" << jt.first << " " << jt.second << std::endl; + edm::LogInfo("TriggerObjectBlock") << "\t\t\t\t\t" << jt.first << " " << jt.second;; } - list_->push_back(_tobj); } fnTriggerObject_ = list_->size(); } - else { + else edm::LogError("TriggerObjectBlock") << "Failed to get TriggerObjects for label: " << objectTag_; - } } - else { + else edm::LogError("TriggerObjectBlock") << "Failed to get TriggerResults for label: " << hltTag_; +} +void TriggerObjectBlock::printObjectInfo(const pat::TriggerObjectStandAlone& obj) +{ + edm::LogInfo("TriggerObjectBlock") << "\tTrigger object: pt " << obj.pt() + << ", eta " << obj.eta() + << ", phi " << obj.phi(); + // Print trigger object collection and type + edm::LogInfo("TriggerObjectBlock") << "\t Collection: " << obj.collection() << "\n" + << "\t Type IDs: "; + for (unsigned h = 0; h < obj.filterIds().size(); ++h) + edm::LogInfo("TriggerObjectBlock") << " " << obj.filterIds()[h] ; + + // Print associated trigger filters + edm::LogInfo("TriggerObjectBlock") << "\t Filters: "; + for (unsigned h = 0; h < obj.filterLabels().size(); ++h) + edm::LogInfo("TriggerObjectBlock") << " " << obj.filterLabels()[h]; + + std::vector pathNamesAll = obj.pathNames(false); + std::vector pathNamesLast = obj.pathNames(true); + + // Print all trigger paths, for each one record also if the object is associated to a 'l3' filter (always true for the + // definition used in the PAT trigger producer) and if it's associated to the last filter of a successfull path (which + // means that this object did cause this trigger to succeed; however, it doesn't work on some multi-object triggers) + edm::LogInfo("TriggerObjectBlock") << "\t Paths (" << pathNamesAll.size()<<"/"< +#include + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "PhysicsTools/PatUtils/interface/TriggerHelper.h" +#include "DataFormats/Common/interface/TriggerResults.h" +#include "FWCore/Common/interface/TriggerNames.h" + +#include "AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h" +#include "AnalysisSpace/TreeMaker/interface/Utility.h" +#include "AnalysisSpace/TreeMaker/interface/PhysicsObjects.h" + +#include "TMath.h" +#include "TTree.h" +#include "TPRegexp.h" + +// Constructor +TriggerObjectBlock::TriggerObjectBlock(const edm::ParameterSet& iConfig) : + verbosity_(iConfig.getUntrackedParameter("verbosity", 0)), + hltPathsOfInterest_(iConfig.getParameter >("hltPathsOfInterest")), + hltPattern_(iConfig.getParameter("hltPattern")), + minTrigObjPt_(iConfig.getUntrackedParameter("minTrigObjPt", 5.0)), + hltTag_(iConfig.getUntrackedParameter("hltInputTag", edm::InputTag("TriggerResults","","HLT"))), + objectTag_(iConfig.getUntrackedParameter("triggerObjectTag", edm::InputTag("selectedPatTrigger"))), + hltToken_(consumes(hltTag_)), + objectToken_(consumes(objectTag_)) +{ + std::cout << "hltPattern = " << std::endl + << hltPattern_ + << std::endl; + re_ = new TPMERegexp(hltPattern_, "xo"); +} +TriggerObjectBlock::~TriggerObjectBlock() { + if (re_) delete re_; +} +void TriggerObjectBlock::beginJob() +{ + std::string tree_name = "vhtree"; + TTree* tree = vhtm::Utility::getTree(tree_name); + list_ = new std::vector(); + tree->Branch("TriggerObject", "std::vector", &list_, 32000, 2); + tree->Branch("nTriggerObject", &fnTriggerObject_, "fnTriggerObject_/I"); +} +void TriggerObjectBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + // Reset the vector and the nObj variables + list_->clear(); + fnTriggerObject_ = 0; + + if (verbosity_) { + std::cout << setiosflags(std::ios::fixed); + std::cout << "Indx Eta Phi Pt Energy =Trigger path list=" << std::endl; + } + + edm::Handle triggerBits; + bool found = iEvent.getByToken(hltToken_, triggerBits); + if (found && triggerBits.isValid()) { + edm::Handle triggerObjects; + found = iEvent.getByToken(objectToken_, triggerObjects); + if (found && triggerObjects.isValid()) { + // Find the triggerNames and the matched paths + const edm::TriggerNames& names = iEvent.triggerNames(*triggerBits); + for (const std::string& v: names.triggerNames()) + if (re_->Match(v)) matchedPathList_.push_back(v); + + for (pat::TriggerObjectStandAlone obj: *triggerObjects) { + if (obj.pt() < minTrigObjPt_) continue; + obj.unpackPathNames(names); + + std::map pathInfoMap; + for (const std::string& v: matchedPathList_) { + int val = -1; + if (obj.hasPathName(v, true, true)) val = 3; + else if (obj.hasPathName(v, false, true)) val = 2; + else if (obj.hasPathName(v, true, false)) val = 1; + else if (obj.hasPathName(v, false, false)) val = 0; + if (val > -1) pathInfoMap.insert(std::pair(v, val)); + } + + if (list_->size() == kMaxTriggerObject_) { + edm::LogInfo("TriggerObjectBlock") << "Too many Trigger Muons (HLT), fnTriggerObject = " + << list_->size(); + break; + } + vhtm::TriggerObject _tobj; + _tobj.eta = obj.eta(); + _tobj.phi = obj.phi(); + _tobj.pt = obj.pt(); + _tobj.energy = obj.energy(); + _tobj.pathList = pathInfoMap; + + if (verbosity_) { + std::cout << std::setprecision(2); + std::cout << std::setw(4) << fnTriggerObject_++ + << std::setw(8) << _tobj.eta + << std::setw(8) << _tobj.phi + << std::setw(8) << _tobj.pt + << std::setw(8) << _tobj.energy + << std::endl; + for (auto jt: _tobj.pathList) + std::cout << "\t\t\t\t\t" << jt.first << " " << jt.second << std::endl; + } + list_->push_back(_tobj); + } + fnTriggerObject_ = list_->size(); + } + else { + edm::LogError("TriggerObjectBlock") << "Failed to get TriggerObjects for label: " + << objectTag_; + } + } + else { + edm::LogError("TriggerObjectBlock") << "Failed to get TriggerResults for label: " + << hltTag_; + } +} +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(TriggerObjectBlock); diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h index de581c2..7d335b5 100644 --- a/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h +++ b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h @@ -15,10 +15,10 @@ #include "DataFormats/Common/interface/Handle.h" #include "DataFormats/Provenance/interface/EventID.h" #include "FWCore/ParameterSet/interface/ProcessDesc.h" +#include "HLTrigger/HLTcore/interface/HLTConfigProvider.h" #include "DataFormats/PatCandidates/interface/TriggerObjectStandAlone.h" -class TPMERegexp; namespace vhtm { class TriggerObject; } @@ -26,17 +26,17 @@ namespace vhtm { class TriggerObjectBlock : public edm::EDAnalyzer { private: - virtual void beginJob(); - virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} - virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); - virtual void endJob() {} + virtual void beginJob() override; + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) override; + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup); public: explicit TriggerObjectBlock(const edm::ParameterSet& iConfig); virtual ~TriggerObjectBlock(); + static void printObjectInfo(const pat::TriggerObjectStandAlone& obj); enum { - kMaxTriggerObject_ = 100 + kMaxTriggerObject_ = 200 }; private: @@ -44,12 +44,8 @@ class TriggerObjectBlock : public edm::EDAnalyzer std::vector* list_; const int verbosity_; - const std::vector hltPathsOfInterest_; - const std::string hltPattern_; const double minTrigObjPt_; - - TPMERegexp* re_; - std::vector matchedPathList_; + HLTConfigProvider hltConfig_; const edm::InputTag hltTag_; const edm::InputTag objectTag_; diff --git a/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h.saved b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h.saved new file mode 100644 index 0000000..de581c2 --- /dev/null +++ b/AnalysisSpace/TreeMaker/plugins/TriggerObjectBlock.h.saved @@ -0,0 +1,60 @@ +#ifndef __AnalysisSpace_TreeMaker_TriggerObjectBlock_h +#define __AnalysisSpace_TreeMaker_TriggerObjectBlock_h + +#include +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "DataFormats/Common/interface/Ref.h" + +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Provenance/interface/EventID.h" +#include "FWCore/ParameterSet/interface/ProcessDesc.h" + +#include "DataFormats/PatCandidates/interface/TriggerObjectStandAlone.h" + +class TPMERegexp; +namespace vhtm { + class TriggerObject; +} + +class TriggerObjectBlock : public edm::EDAnalyzer +{ +private: + virtual void beginJob(); + virtual void beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {} + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + virtual void endJob() {} + +public: + explicit TriggerObjectBlock(const edm::ParameterSet& iConfig); + virtual ~TriggerObjectBlock(); + + enum { + kMaxTriggerObject_ = 100 + }; + +private: + int fnTriggerObject_; + std::vector* list_; + + const int verbosity_; + const std::vector hltPathsOfInterest_; + const std::string hltPattern_; + const double minTrigObjPt_; + + TPMERegexp* re_; + std::vector matchedPathList_; + + const edm::InputTag hltTag_; + const edm::InputTag objectTag_; + + const edm::EDGetTokenT hltToken_; + const edm::EDGetTokenT objectToken_; +}; +#endif diff --git a/AnalysisSpace/TreeMaker/plugins/VertexBlock.cc b/AnalysisSpace/TreeMaker/plugins/VertexBlock.cc index 2e212fe..9ae0356 100644 --- a/AnalysisSpace/TreeMaker/plugins/VertexBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/VertexBlock.cc @@ -20,7 +20,7 @@ void VertexBlock::beginJob() { // Get TTree pointer TTree* tree = vhtm::Utility::getTree("vhtree"); list_ = new std::vector(); - tree->Branch("Vertex", "std::vector", &list_, 32000, 2); + tree->Branch("Vertex", "std::vector", &list_, 32000, -1); tree->Branch("nVertex", &fnVertex_, "fnVertex_/I"); } void VertexBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { diff --git a/AnalysisSpace/TreeMaker/python/CalibratedElectronBlock_bx25_cfi.py b/AnalysisSpace/TreeMaker/python/CalibratedElectronBlock_bx25_cfi.py new file mode 100644 index 0000000..8b7531d --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/CalibratedElectronBlock_bx25_cfi.py @@ -0,0 +1,17 @@ +import FWCore.ParameterSet.Config as cms + +calibelectronBlock = cms.EDAnalyzer("ElectronBlock", + verbosity = cms.untracked.int32(1), + beamSpotCorr = cms.untracked.bool(True), + useTrigMode = cms.untracked.bool(False), + offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot'), + #vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + vertexSrc = cms.untracked.InputTag('selectedPrimaryVertices'), + electronSrc = cms.untracked.InputTag('calibratedElectrons'), + eleMediumIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp90"), + eleTightIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp80"), + mvaValuesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values"), + mvaCategoriesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories"), + objectbranchName = cms.string("CalibratedElectron") +) + diff --git a/AnalysisSpace/TreeMaker/python/ElectronBlock_bx25_cfi.py b/AnalysisSpace/TreeMaker/python/ElectronBlock_bx25_cfi.py new file mode 100644 index 0000000..1065210 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/ElectronBlock_bx25_cfi.py @@ -0,0 +1,17 @@ +import FWCore.ParameterSet.Config as cms + +electronBlock = cms.EDAnalyzer("ElectronBlock", + verbosity = cms.untracked.int32(1), + beamSpotCorr = cms.untracked.bool(True), + useTrigMode = cms.untracked.bool(False), + offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot'), + #vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + vertexSrc = cms.untracked.InputTag('selectedPrimaryVertices'), + electronSrc = cms.untracked.InputTag('slimmedElectrons'), + eleMediumIdMap = cms.InputTag("egmGsfElectronIDsSlimmed:mvaEleID-Spring15-25ns-nonTrig-V1-wp90"), + eleTightIdMap = cms.InputTag("egmGsfElectronIDsSlimmed:mvaEleID-Spring15-25ns-nonTrig-V1-wp80"), + mvaValuesMap = cms.InputTag("electronMVAValueMapProducerSlimmed:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values"), + mvaCategoriesMap = cms.InputTag("electronMVAValueMapProducerSlimmed:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories"), + objectbranchName = cms.string("Electron") +) + diff --git a/AnalysisSpace/TreeMaker/python/ElectronBlock_bx25_cfi.py.CSA14 b/AnalysisSpace/TreeMaker/python/ElectronBlock_bx25_cfi.py.CSA14 new file mode 100644 index 0000000..0ff14e9 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/ElectronBlock_bx25_cfi.py.CSA14 @@ -0,0 +1,17 @@ +import FWCore.ParameterSet.Config as cms + +electronBlock = cms.EDAnalyzer("ElectronBlock", + verbosity = cms.untracked.int32(1), + beamSpotCorr = cms.untracked.bool(True), + useTrigMode = cms.untracked.bool(False), + offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot'), + vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + electronSrc = cms.untracked.InputTag('slimmedElectrons'), + MVAId = cms.InputTag("mvaNonTrigV025nsCSA14","","addMVAid"), + mvaWeightFiles = cms.vstring( + "EgammaAnalysis/ElectronTools/data/CSA14/EIDmva_EB_5_25ns_BDT.weights.xml", + "EgammaAnalysis/ElectronTools/data/CSA14/EIDmva_EB_10_25ns_BDT.weights.xml", + "EgammaAnalysis/ElectronTools/data/CSA14/EIDmva_EE_5_25ns_BDT.weights.xml", + "EgammaAnalysis/ElectronTools/data/CSA14/EIDmva_EE_10_25ns_BDT.weights.xml", + ) +) diff --git a/AnalysisSpace/TreeMaker/python/ElectronBlock_bx50_cfi.py b/AnalysisSpace/TreeMaker/python/ElectronBlock_bx50_cfi.py new file mode 100644 index 0000000..949a62b --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/ElectronBlock_bx50_cfi.py @@ -0,0 +1,16 @@ +import FWCore.ParameterSet.Config as cms + +electronBlock = cms.EDAnalyzer("ElectronBlock", + verbosity = cms.untracked.int32(1), + beamSpotCorr = cms.untracked.bool(True), + useTrigMode = cms.untracked.bool(False), + offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot'), +# vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + vertexSrc = cms.untracked.InputTag('selectedPrimaryVertices'), + electronSrc = cms.untracked.InputTag('slimmedElectrons'), + eleMediumIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp90"), + eleTightIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp80"), + mvaValuesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values"), + mvaCategoriesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories") +) + diff --git a/AnalysisSpace/TreeMaker/python/EventBlock_cfi.py b/AnalysisSpace/TreeMaker/python/EventBlock_cfi.py index 787f36a..0a5238b 100644 --- a/AnalysisSpace/TreeMaker/python/EventBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/EventBlock_cfi.py @@ -11,8 +11,8 @@ #numTracks = cms.untracked.uint32(10), hpTrackThreshold = cms.untracked.double(0.25), puSummaryInputTag = cms.untracked.InputTag('addPileupInfo'), - #selectedVtxInputTag = cms.untracked.InputTag('selectedPrimaryVertices'), - selectedVtxInputTag = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + selectedVtxInputTag = cms.untracked.InputTag('selectedPrimaryVertices'), + #selectedVtxInputTag = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), rhoInputTag = cms.untracked.InputTag('kt6PFJets','rho'), rhoNeutralInputTag = cms.untracked.InputTag('kt6PFNeutralJetsForVtxMultReweighting', 'rho') ) diff --git a/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.py b/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.py index 0f3c8ee..86f8ae9 100644 --- a/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/MuonBlock_cfi.py @@ -3,7 +3,9 @@ muonBlock = cms.EDAnalyzer("MuonBlock", verbosity = cms.untracked.int32(0), muonSrc = cms.untracked.InputTag('slimmedMuons'), - vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + #muonSrc = cms.untracked.InputTag('cleanedMu'), + #vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + vertexSrc = cms.untracked.InputTag('selectedPrimaryVertices'), offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot'), beamSpotCorr = cms.untracked.bool(True), muonID = cms.untracked.string('GlobalMuonPromptTight') diff --git a/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py b/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py index f12e26f..6031287 100644 --- a/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/PackedPFCandidateBlock_cfi.py @@ -1,7 +1,7 @@ import FWCore.ParameterSet.Config as cms packedPFCandidateBlock = cms.EDAnalyzer("PackedPFCandidateBlock", - verbosity = cms.untracked.int32(1), + verbosity = cms.untracked.int32(0), pfCands = cms.untracked.InputTag('packedPFCandidates'), - pdgTosave = cms.vint32( 11,13,15,22 ) + pdgTosave = cms.vint32( 22 ) ) diff --git a/AnalysisSpace/TreeMaker/python/TauBlock_cfi.py b/AnalysisSpace/TreeMaker/python/TauBlock_cfi.py index 607b5da..2c1d402 100644 --- a/AnalysisSpace/TreeMaker/python/TauBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/TauBlock_cfi.py @@ -3,7 +3,8 @@ tauBlock = cms.EDAnalyzer("TauBlock", verbosity = cms.untracked.int32(0), patTauSrc = cms.untracked.InputTag('slimmedTaus'), - vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + #vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices'), + vertexSrc = cms.untracked.InputTag('selectedPrimaryVertices'), beamSpotCorr = cms.untracked.bool(True), offlineBeamSpot = cms.untracked.InputTag('offlineBeamSpot') ) diff --git a/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx25_DYJets_cff.py b/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx25_DYJets_cff.py new file mode 100644 index 0000000..57caa68 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx25_DYJets_cff.py @@ -0,0 +1,35 @@ +import FWCore.ParameterSet.Config as cms + +from AnalysisSpace.TreeMaker.EventBlock_cfi import eventBlock +#from AnalysisSpace.TreeMaker.GenEventBlock_cfi import genEventBlock +from AnalysisSpace.TreeMaker.VertexBlock_cfi import vertexBlock +#from AnalysisSpace.TreeMaker.GenJetBlock_cfi import genJetBlock +from AnalysisSpace.TreeMaker.JetBlock_cfi import jetBlock +from AnalysisSpace.TreeMaker.ElectronBlock_bx25_cfi import electronBlock +from AnalysisSpace.TreeMaker.PhotonBlock_cfi import photonBlock +from AnalysisSpace.TreeMaker.METBlock_cfi import metBlock +#from AnalysisSpace.TreeMaker.GenMETBlock_cfi import genMETBlock +from AnalysisSpace.TreeMaker.MuonBlock_cfi import muonBlock +from AnalysisSpace.TreeMaker.TauBlock_cfi import tauBlock +from AnalysisSpace.TreeMaker.GenParticleBlock_cfi import genParticleBlock +from AnalysisSpace.TreeMaker.TriggerBlock_cfi import triggerBlock +from AnalysisSpace.TreeMaker.TriggerObjectBlock_cfi import triggerObjectBlock +from AnalysisSpace.TreeMaker.PackedPFCandidateBlock_cfi import packedPFCandidateBlock + +treeContentSequence = cms.Sequence( + eventBlock + + triggerBlock + + triggerObjectBlock + + vertexBlock +# + genEventBlock +# + genParticleBlock +# + genJetBlock +# + genMETBlock + + electronBlock + + photonBlock + + muonBlock + + tauBlock + + metBlock + + jetBlock + + packedPFCandidateBlock +) diff --git a/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx25_cff.py b/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx25_cff.py new file mode 100644 index 0000000..5db8833 --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx25_cff.py @@ -0,0 +1,37 @@ +import FWCore.ParameterSet.Config as cms + +from AnalysisSpace.TreeMaker.EventBlock_cfi import eventBlock +#from AnalysisSpace.TreeMaker.GenEventBlock_cfi import genEventBlock +from AnalysisSpace.TreeMaker.VertexBlock_cfi import vertexBlock +#from AnalysisSpace.TreeMaker.GenJetBlock_cfi import genJetBlock +from AnalysisSpace.TreeMaker.JetBlock_cfi import jetBlock +from AnalysisSpace.TreeMaker.ElectronBlock_bx25_cfi import electronBlock +from AnalysisSpace.TreeMaker.CalibratedElectronBlock_bx25_cfi import calibelectronBlock +from AnalysisSpace.TreeMaker.PhotonBlock_cfi import photonBlock +from AnalysisSpace.TreeMaker.METBlock_cfi import metBlock +#from AnalysisSpace.TreeMaker.GenMETBlock_cfi import genMETBlock +from AnalysisSpace.TreeMaker.MuonBlock_cfi import muonBlock +from AnalysisSpace.TreeMaker.TauBlock_cfi import tauBlock +from AnalysisSpace.TreeMaker.GenParticleBlock_cfi import genParticleBlock +from AnalysisSpace.TreeMaker.TriggerBlock_cfi import triggerBlock +from AnalysisSpace.TreeMaker.TriggerObjectBlock_cfi import triggerObjectBlock +from AnalysisSpace.TreeMaker.PackedPFCandidateBlock_cfi import packedPFCandidateBlock + +treeContentSequence = cms.Sequence( + eventBlock + + triggerBlock +# + triggerObjectBlock + + vertexBlock +# + genEventBlock + + genParticleBlock +# + genJetBlock +# + genMETBlock + + electronBlock + + calibelectronBlock + + photonBlock + + muonBlock +# + tauBlock + + metBlock + + jetBlock + + packedPFCandidateBlock +) diff --git a/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx50_cff.py b/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx50_cff.py new file mode 100644 index 0000000..1b492fb --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/TreeContentConfig_bx50_cff.py @@ -0,0 +1,35 @@ +import FWCore.ParameterSet.Config as cms + +from AnalysisSpace.TreeMaker.EventBlock_cfi import eventBlock +#from AnalysisSpace.TreeMaker.GenEventBlock_cfi import genEventBlock +from AnalysisSpace.TreeMaker.VertexBlock_cfi import vertexBlock +#from AnalysisSpace.TreeMaker.GenJetBlock_cfi import genJetBlock +from AnalysisSpace.TreeMaker.JetBlock_cfi import jetBlock +from AnalysisSpace.TreeMaker.ElectronBlock_bx50_cfi import electronBlock +from AnalysisSpace.TreeMaker.PhotonBlock_cfi import photonBlock +from AnalysisSpace.TreeMaker.METBlock_cfi import metBlock +#from AnalysisSpace.TreeMaker.GenMETBlock_cfi import genMETBlock +from AnalysisSpace.TreeMaker.MuonBlock_cfi import muonBlock +from AnalysisSpace.TreeMaker.TauBlock_cfi import tauBlock +from AnalysisSpace.TreeMaker.GenParticleBlock_cfi import genParticleBlock +from AnalysisSpace.TreeMaker.TriggerBlock_cfi import triggerBlock +from AnalysisSpace.TreeMaker.TriggerObjectBlock_cfi import triggerObjectBlock +from AnalysisSpace.TreeMaker.PackedPFCandidateBlock_cfi import packedPFCandidateBlock + +treeContentSequence = cms.Sequence( + eventBlock + + triggerBlock + + triggerObjectBlock + + vertexBlock +# + genEventBlock + + genParticleBlock +# + genJetBlock +# + genMETBlock + + electronBlock + + photonBlock + + muonBlock + + tauBlock + + metBlock + + jetBlock + + packedPFCandidateBlock +) diff --git a/AnalysisSpace/TreeMaker/python/TreeContentConfig_data_cff.py b/AnalysisSpace/TreeMaker/python/TreeContentConfig_data_cff.py index a561225..e091e32 100644 --- a/AnalysisSpace/TreeMaker/python/TreeContentConfig_data_cff.py +++ b/AnalysisSpace/TreeMaker/python/TreeContentConfig_data_cff.py @@ -2,22 +2,26 @@ from AnalysisSpace.TreeMaker.EventBlock_cfi import eventBlock from AnalysisSpace.TreeMaker.VertexBlock_cfi import vertexBlock -from AnalysisSpace.TreeMaker.ElectronBlock_cfi import electronBlock +from AnalysisSpace.TreeMaker.ElectronBlock_bx25_cfi import electronBlock +from AnalysisSpace.TreeMaker.CalibratedElectronBlock_bx25_cfi import calibelectronBlock from AnalysisSpace.TreeMaker.MuonBlock_cfi import muonBlock from AnalysisSpace.TreeMaker.TauBlock_cfi import tauBlock from AnalysisSpace.TreeMaker.JetBlock_cfi import jetBlock from AnalysisSpace.TreeMaker.METBlock_cfi import metBlock from AnalysisSpace.TreeMaker.TriggerBlock_cfi import triggerBlock from AnalysisSpace.TreeMaker.TriggerObjectBlock_cfi import triggerObjectBlock +from AnalysisSpace.TreeMaker.PackedPFCandidateBlock_cfi import packedPFCandidateBlock treeContentSequence = cms.Sequence( eventBlock + vertexBlock + electronBlock + + calibelectronBlock + muonBlock - + tauBlock +# + tauBlock + jetBlock + metBlock + triggerBlock + triggerObjectBlock + + packedPFCandidateBlock ) diff --git a/AnalysisSpace/TreeMaker/python/TriggerBlock_cfi.py b/AnalysisSpace/TreeMaker/python/TriggerBlock_cfi.py index 20d6fb0..2081b08 100644 --- a/AnalysisSpace/TreeMaker/python/TriggerBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/TriggerBlock_cfi.py @@ -4,11 +4,18 @@ verbosity = cms.untracked.int32(0), l1InputTag = cms.untracked.InputTag('gtDigis'), hltInputTag = cms.untracked.InputTag('TriggerResults','','HLT'), - hltPathsOfInterest = cms.vstring ("HLT_DoubleMu", - "HLT_Mu", - "HLT_IsoMu", - "HLT_TripleMu", - "IsoPFTau", - "TrkIsoT", - "HLT_Ele") + hltPathsOfInterest = cms.vstring ( + 'HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v', + 'HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v', + 'HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v', + 'HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v', + 'HLT_TripleMu_12_10_5_v', + 'HLT_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL_v', + 'HLT_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v', + 'HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v', + 'HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v', + 'HLT_Ele27_WPLoose_Gsf_v', + 'HLT_Ele27_WP85_Gsf_v' + ) + ) diff --git a/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py b/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py index 7f0cc7f..7ece3a4 100644 --- a/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py @@ -1,33 +1,9 @@ import FWCore.ParameterSet.Config as cms triggerObjectBlock = cms.EDAnalyzer("TriggerObjectBlock", - verbosity = cms.untracked.int32(0), - hltInputTag = cms.untracked.InputTag('TriggerResults','','HLT'), - triggerEventTag = cms.untracked.InputTag('patTriggerEvent'), - hltPathsOfInterest = cms.vstring ("HLT_DoubleMu", - "HLT_Mu13_Mu8_v", - "HLT_Mu17_Mu8_v", - "HLT_Mu1", - "HLT_Mu2", - "HLT_Mu3", - "HLT_Mu4", - "HLT_IsoMu1", - "HLT_IsoMu2", - "HLT_IsoMu3", - "HLT_IsoMu4", - "HLT_Mu17_Ele8_Calo", - "HLT_Mu8_Ele17_", - "HLT_Ele1", - "HLT_Ele2", - "HLT_Ele3", - "HLT_Ele4", - "IsoPFTau"), - hltPattern - = cms.string(r""" -HLT_(Mu\\d{1,2}_Ele\\d{1,2}_(?:Calo)? | -Ele[1-4][0-9] | -[^(QuadJet\\d+_)]IsoPFTau) -"""), - minTrigObjPt = cms.untracked.double(8.0), - May10ReRecoData = cms.untracked.bool(False) -) + verbosity = cms.untracked.int32(0), + minTrigObjPt = cms.untracked.double(8.0), + hltInputTag = cms.untracked.InputTag('TriggerResults','','HLT'), + triggerObjectTag = cms.untracked.InputTag('selectedPatTrigger'), + ) + diff --git a/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py~ b/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py~ new file mode 100644 index 0000000..b1f2bfe --- /dev/null +++ b/AnalysisSpace/TreeMaker/python/TriggerObjectBlock_cfi.py~ @@ -0,0 +1,8 @@ +import FWCore.ParameterSet.Config as cms + +triggerObjectBlock = cms.EDAnalyzer("TriggerObjectBlock", + verbosity = cms.untracked.int32(0), + minTrigObjPt = cms.untracked.double(8.0), + hltInputTag = cms.untracked.InputTag('TriggerResults','','HLT'), + triggerObjectTag = cms.untracked.InputTag('selectedPatTrigger'), +) diff --git a/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.py b/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.py index e046b01..5462d44 100644 --- a/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.py +++ b/AnalysisSpace/TreeMaker/python/VertexBlock_cfi.py @@ -1,6 +1,7 @@ import FWCore.ParameterSet.Config as cms vertexBlock = cms.EDAnalyzer("VertexBlock", - verbosity = cms.untracked.int32(1), - vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices') + verbosity = cms.untracked.int32(0), + #vertexSrc = cms.untracked.InputTag('offlineSlimmedPrimaryVertices') + vertexSrc = cms.untracked.InputTag('selectedPrimaryVertices') ) diff --git a/AnalysisSpace/TreeMaker/python/__init__.py b/AnalysisSpace/TreeMaker/python/__init__.py index 6009e7f..fadcf07 100644 --- a/AnalysisSpace/TreeMaker/python/__init__.py +++ b/AnalysisSpace/TreeMaker/python/__init__.py @@ -1,3 +1,3 @@ #Automatically created by SCRAM import os -__path__.append(os.path.dirname(os.path.abspath(__file__).rsplit('/AnalysisSpace/TreeMaker/',1)[0])+'/cfipython/slc6_amd64_gcc481/AnalysisSpace/TreeMaker') +__path__.append(os.path.dirname(os.path.abspath(__file__).rsplit('/AnalysisSpace/TreeMaker/',1)[0])+'/cfipython/slc6_amd64_gcc491/AnalysisSpace/TreeMaker') diff --git a/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc b/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc index 7719728..56dcfc7 100644 --- a/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc +++ b/AnalysisSpace/TreeMaker/src/PhysicsObjects.cc @@ -2,14 +2,26 @@ #define NEL(x) (sizeof((x))/sizeof((x)[0])) +ClassImp(vhtm::Event) +ClassImp(vhtm::GenEvent) +ClassImp(vhtm::Electron) +ClassImp(vhtm::GenParticle) +ClassImp(vhtm::GenJet) +ClassImp(vhtm::GenMET) +ClassImp(vhtm::MET) +ClassImp(vhtm::Tau) +ClassImp(vhtm::Muon) +ClassImp(vhtm::Jet) +ClassImp(vhtm::Vertex) +ClassImp(vhtm::TriggerObject) +ClassImp(vhtm::Candidate) +ClassImp(vhtm::Photon) +ClassImp(vhtm::PackedPFCandidate) + vhtm::Candidate::Candidate(): - pt(-999), eta(-999), phi(-999) -{} -vhtm::Candidate::Candidate(float _pt, float _eta, float _phi): - pt(_pt), eta(_eta), phi(_phi) -{} -vhtm::PackedPFCandidate::PackedPFCandidate(): - pt(-999.), + pt(-999), eta(-999), phi(-999) {} vhtm::Candidate::Candidate(float _pt, float _eta, float _phi): + pt(_pt), eta(_eta), phi(_phi) {} vhtm::PackedPFCandidate::PackedPFCandidate(): + pt(-999.), eta(-999.), phi(-999.), energy(-999.), @@ -92,6 +104,7 @@ vhtm::Electron::Electron(): scET(-999), scRawEnergy(-999), BDT(-999), + BDTpreComp(-999), dxyPV(-999), dzPV(-999), vtxDist3D(-999), @@ -117,7 +130,10 @@ vhtm::Electron::Electron(): mvaPreselection(false), isTriggerElectron(false), fidFlag(0), - selbit(0) + selbit(0), + passMediumId(false), + passTightId(false), + mvaCategory(false) { idmap.clear(); } @@ -230,6 +246,7 @@ vhtm::Muon::Muon(): isGlobalMuon(false), isTrackerMuon(false), isPFMuon(false), + isghostCleaned(false), eta(-999), phi(-999), pt(-999), @@ -238,6 +255,7 @@ vhtm::Muon::Muon(): charge(-999), trkD0(-999), trkDz(-999), + muonBestTrackType(-999), globalChi2(9999.), tkNChi2(9999.), trkIso(-999), @@ -249,8 +267,11 @@ vhtm::Muon::Muon(): pfPhotonIso03(999.), sumPUPt03(-999), pfRelIso03(-1), - pfChargedIsoR04(-999), - sumPUPt04(-999), + sumChargedParticlePt(999.), + sumChargedHadronPt(999.), + sumNeutralHadronEt(999.), + sumPhotonEt(999.), + sumPUPt(999.), pfRelIso04(-1), passID(false), dxyPV(-999), @@ -279,6 +300,7 @@ vhtm::Muon::Muon(): stationGapMaskDistance(0), stationGapMaskPull(0), muonID(false), + nSegments(-1), selbit(0) {} @@ -313,7 +335,9 @@ vhtm::Jet::Jet(): combinedSecondaryVertexBTag(-999), //combinedSecondaryVertexMVABTag(-999), combinedInclusiveSecondaryVertexBTag(-999), + pfCombinedInclusiveSecondaryVertexV2BJetTags(-999.), //combinedMVABTag(-999), + jpumva(9999.), passLooseID(-1), passTightID(-1), selbit(0) diff --git a/AnalysisSpace/TreeMaker/src/classes_def.xml b/AnalysisSpace/TreeMaker/src/classes_def.xml index 7cd2343..db988d9 100644 --- a/AnalysisSpace/TreeMaker/src/classes_def.xml +++ b/AnalysisSpace/TreeMaker/src/classes_def.xml @@ -1,48 +1,48 @@ - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + diff --git a/AnalysisSpace/TreeMaker/test/miniAODprod_MCbx25_V2_SYNC23OCT.py b/AnalysisSpace/TreeMaker/test/miniAODprod_MCbx25_V2_SYNC23OCT.py new file mode 100644 index 0000000..e699935 --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/miniAODprod_MCbx25_V2_SYNC23OCT.py @@ -0,0 +1,152 @@ +import FWCore.ParameterSet.Config as cms +process = cms.Process("TreeMaker") +#------------------------ +# Message Logger Settings +#------------------------ +process.load('Configuration.StandardSequences.Services_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load("FWCore.MessageLogger.MessageLogger_cfi") +process.MessageLogger.cerr.FwkReport.reportEvery = 1 +process.MessageLogger.infos.threshold = cms.untracked.string("ERROR") +#-------------------------------------- +# Event Source & # of Events to process +#--------------------------------------- +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( + '/store/mc/RunIISpring15MiniAODv2/VBF_HToZZTo4L_M125_13TeV_powheg_JHUgen_pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/30000/3E964C5D-1D6E-E511-8B9A-0050560207C5.root', + #'/store/mc/RunIISpring15MiniAODv2/WminusH_HToZZTo4L_M125_13TeV_powheg-minlo-HWJ_JHUgen_pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/30000/D8CA6B54-056F-E511-BB1A-02163E014CE3.root', + #'/store/mc/RunIISpring15MiniAODv2/WplusH_HToZZTo4L_M125_13TeV_powheg-minlo-HWJ_JHUgen_pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/40000/D22BEE88-C26D-E511-B330-002590A81EF0.root', + #'/store/mc/RunIISpring15MiniAODv2/ttH_HToZZ_4LFilter_M125_13TeV_powheg_JHUgen_pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/80000/84F62DD7-1475-E511-9F59-009C02AB98A6.root' + ) +) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(10) +) +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False) ) + +#----------------------------- +# Geometry +#----------------------------- +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +#process.load("Configuration.StandardSequences.Geometry_cff") +#----------------------------- +# Magnetic Field +#----------------------------- +process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff') +#------------- +# Global Tag +#------------- +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff') +process.GlobalTag.globaltag = '74X_mcRun2_asymptotic_v2' +#process.GlobalTag.globaltag = 'auto:run2_data' +#GR_P_V_56 +# +#------------- +# Output ROOT file +#------------- +process.TFileService = cms.Service("TFileService", + fileName = cms.string('HZZ4lminiAOD_CATSYNC23rdOct_new.root') +) +#-------------------------------------------------- +# Analysis Tree Specific +#-------------------------------------------------- +process.load("AnalysisSpace.TreeMaker.TreeCreator_cfi") +process.load("AnalysisSpace.TreeMaker.TreeWriter_cfi") +#process.load("AnalysisSpace.TreeMaker.TreeContentConfig_bx50_cff") +process.load("AnalysisSpace.TreeMaker.TreeContentConfig_bx25_cff") + + +# Primary Vertex Selector +process.selectedPrimaryVertices = cms.EDFilter("VertexSelector", + src = cms.InputTag('offlineSlimmedPrimaryVertices'), + cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && abs(position.Rho) <= 2"), + filter = cms.bool(True) +) + +# Sequence for rhoNeutral +from CommonTools.ParticleFlow.ParticleSelectors.pfAllNeutralHadrons_cfi import pfAllNeutralHadrons +from CommonTools.ParticleFlow.ParticleSelectors.pfAllPhotons_cfi import pfAllPhotons +pfNeutralCandPdgIds = [] +pfNeutralCandPdgIds.extend(pfAllNeutralHadrons.pdgId.value()) +pfNeutralCandPdgIds.extend(pfAllPhotons.pdgId.value()) + +process.pfNeutralCands = cms.EDFilter("PdgIdPFCandidateSelector", + src = cms.InputTag('particleFlow'), + pdgId = cms.vint32(pfNeutralCandPdgIds) +) +from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets +process.kt6PFNeutralJetsForVtxMultReweighting = kt4PFJets.clone( + src = cms.InputTag('pfNeutralCands'), + rParam = cms.double(0.6), + doRhoFastjet = cms.bool(True), + Rho_EtaMax = cms.double(2.5) +) +process.kt6PFJets = kt4PFJets.clone( + rParam = cms.double(0.6), + doRhoFastjet = cms.bool(True), + Rho_EtaMax = cms.double(2.5) +) + +process.cleanedMu = cms.EDProducer("PATMuonCleanerBySegments", + src = cms.InputTag("calibratedMuons"), + preselection = cms.string("track.isNonnull"), + passthrough = cms.string("isGlobalMuon && numberOfMatches >= 2"), + fractionOfSharedSegments = cms.double(0.499) +) + +################################################################# +# +# Set up electron ID (VID framework) +# + +from PhysicsTools.SelectorUtils.tools.vid_id_tools import * +# turn on VID producer, indicate data format to be +# DataFormat.AOD or DataFormat.MiniAOD, as appropriate + +switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD) +# define which IDs we want to produce +my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff'] + +#add them to the VID producer +for idmod in my_id_modules: + setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection) +######################################################################## +##############Electron Calibration##################################### +#random number generation +import random +process.load('IOMC.RandomEngine.IOMC_cff') +random.seed() +process.RandomNumberGeneratorService.generator.initialSeed = random.randrange(1,10e07) + +process.selectedSlimmedElectrons = cms.EDFilter("PATElectronSelector", + src = cms.InputTag("slimmedElectrons"), + cut = cms.string("pt > 7."), +) +process.calibratedElectrons = cms.EDProducer("CalibratedPatElectronProducerRun2", + electrons = cms.InputTag("selectedSlimmedElectrons"), + grbForestName = cms.string("gedelectron_p4combination_25ns"), + isMC = cms.bool(True), + isSynchronization = cms.bool(False), +) +####################################################################### + +process.p = cms.Path( + ( process.selectedSlimmedElectrons + process.calibratedElectrons ) * + process.egmGsfElectronIDSequence* + process.selectedPrimaryVertices * + #process.cleanedMu * + #process.kt6PFJets* + #process.pfNeutralCands * + #process.kt6PFNeutralJetsForVtxMultReweighting* + process.treeCreator* + process.treeContentSequence* + process.treeWriter +) + +# List File names here +#--------------------------------------- +#process.PoolSource.fileNames = [ +# '/store/mc/Spring14miniaod/GluGluToHToZZTo4L_M-125_13TeV-powheg-pythia6/MINIAODSIM/PU20bx25_POSTLS170_V5-v1/00000/0881ABEB-2709-E411-9E42-00145EDD7581.root' +#] +#process.PoolSource.fileNames = [''] diff --git a/AnalysisSpace/TreeMaker/test/miniAODprod_MCbx25_V2_ecalib.py b/AnalysisSpace/TreeMaker/test/miniAODprod_MCbx25_V2_ecalib.py new file mode 100644 index 0000000..b9146da --- /dev/null +++ b/AnalysisSpace/TreeMaker/test/miniAODprod_MCbx25_V2_ecalib.py @@ -0,0 +1,102 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("TreeMaker") + +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(-1) +) + +# Input source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( + #'/store/mc/RunIISpring15MiniAODv2/VBF_HToZZTo4L_M125_13TeV_powheg_JHUgen_pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/30000/3E964C5D-1D6E-E511-8B9A-0050560207C5.root', + #'/store/mc/RunIISpring15MiniAODv2/WminusH_HToZZTo4L_M125_13TeV_powheg-minlo-HWJ_JHUgen_pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/30000/D8CA6B54-056F-E511-BB1A-02163E014CE3.root', + #'/store/mc/RunIISpring15MiniAODv2/WplusH_HToZZTo4L_M125_13TeV_powheg-minlo-HWJ_JHUgen_pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/40000/D22BEE88-C26D-E511-B330-002590A81EF0.root', + '/store/mc/RunIISpring15MiniAODv2/ttH_HToZZ_4LFilter_M125_13TeV_powheg_JHUgen_pythia8/MINIAODSIM/74X_mcRun2_asymptotic_v2-v1/80000/84F62DD7-1475-E511-9F59-009C02AB98A6.root' + ) +) + +from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag +process.GlobalTag.globaltag = '74X_mcRun2_asymptotic_v2' + + +#-------------------------------------------------- +# Analysis Tree Specific +#-------------------------------------------------- +process.load("AnalysisSpace.TreeMaker.TreeCreator_cfi") +process.load("AnalysisSpace.TreeMaker.TreeWriter_cfi") +#process.load("AnalysisSpace.TreeMaker.TreeContentConfig_data_cff") +process.load("AnalysisSpace.TreeMaker.TreeContentConfig_bx25_cff") + +process.calibratedElectrons = cms.EDProducer("CalibratedPatElectronProducerRun2", + electrons = cms.InputTag("slimmedElectrons"), + grbForestName = cms.string("gedelectron_p4combination_25ns"), + isMC = cms.bool(True), + isSynchronization = cms.bool(True) +) + + +# Primary Vertex Selector +process.selectedPrimaryVertices = cms.EDFilter("VertexSelector", + src = cms.InputTag('offlineSlimmedPrimaryVertices'), + cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && abs(position.Rho) <= 2"), + filter = cms.bool(True) +) + +process.cleanedMu = cms.EDProducer("PATMuonCleanerBySegments", + src = cms.InputTag("calibratedMuons"), + preselection = cms.string("track.isNonnull"), + passthrough = cms.string("isGlobalMuon && numberOfMatches >= 2"), + fractionOfSharedSegments = cms.double(0.499) +) +################################################################# +# +# Set up electron ID (VID framework) +# + +from PhysicsTools.SelectorUtils.tools.vid_id_tools import * +# turn on VID producer, indicate data format to be +# DataFormat.AOD or DataFormat.MiniAOD, as appropriate + +switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD) +# define which IDs we want to produce +my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff'] + +#add them to the VID producer +for idmod in my_id_modules: + setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection) + +process.egmGsfElectronIDsSlimmed = process.egmGsfElectronIDs.clone(physicsObjectSrc = cms.InputTag("slimmedElectrons")) +process.electronMVAValueMapProducerSlimmed = process.electronMVAValueMapProducer.clone( + srcMiniAOD = cms.InputTag("slimmedElectrons","","@skipCurrentProcess")) +process.electronRegressionValueMapProducerSlimmed = process.electronRegressionValueMapProducer.clone( + srcMiniAOD = cms.InputTag("slimmedElectrons","","@skipCurrentProcess")) +process.egmGsfElectronIDSequenceSlimmed = cms.Sequence( process.electronMVAValueMapProducerSlimmed + + process.egmGsfElectronIDsSlimmed + + process.electronRegressionValueMapProducerSlimmed) + +process.eleMVASequence = cms.Sequence( process.egmGsfElectronIDSequenceSlimmed + process.egmGsfElectronIDSequence ) + + +process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag('calibratedElectrons') +process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag('calibratedElectrons') + +######################################################################## +process.path = cms.Path( + process.calibratedElectrons* + process.eleMVASequence* + process.selectedPrimaryVertices* + process.treeCreator* + process.treeContentSequence* + process.treeWriter +) + +process.TFileService = cms.Service("TFileService", fileName = cms.string('HZZ4lminiAOD_CATSYNC2ndDec.root')) + From f09697f41d71af625d37ab95a5499843425ef7ad Mon Sep 17 00:00:00 2001 From: Suvankar Roy Chowdhury Date: Fri, 4 Dec 2015 15:46:19 +0100 Subject: [PATCH 7/7] gen event weight added to GenEvent class --- AnalysisSpace/TreeMaker/interface/PhysicsObjects.h | 1 + AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc | 4 ++++ AnalysisSpace/TreeMaker/src/classes_def.xml | 2 +- 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h index 187b43c..a01380d 100644 --- a/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h +++ b/AnalysisSpace/TreeMaker/interface/PhysicsObjects.h @@ -93,6 +93,7 @@ namespace vhtm { GenEvent(); virtual ~GenEvent() {} + double weightevt; unsigned int processID; double ptHat; std::vector pdfWeights; diff --git a/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc b/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc index 42339fa..1321f80 100644 --- a/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc +++ b/AnalysisSpace/TreeMaker/plugins/GenEventBlock.cc @@ -52,6 +52,10 @@ void GenEventBlock::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe if (genEvtInfoProduct.isValid()) { edm::LogInfo("GenEventBlock") << "Success. Obtained GenEventInfoProduct for label: " << genEventTag_; + // event weight + double weightevt=genEvtInfoProduct->weight(); + genEvent.weightevt = weightevt; + genEvent.processID = genEvtInfoProduct->signalProcessID(); genEvent.ptHat = genEvtInfoProduct->hasBinningValues() ? genEvtInfoProduct->binningValues()[0] : 0.; diff --git a/AnalysisSpace/TreeMaker/src/classes_def.xml b/AnalysisSpace/TreeMaker/src/classes_def.xml index db988d9..4d0d71c 100644 --- a/AnalysisSpace/TreeMaker/src/classes_def.xml +++ b/AnalysisSpace/TreeMaker/src/classes_def.xml @@ -3,7 +3,7 @@ - +