CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Classes | Public Member Functions | Public Attributes | Private Member Functions | Private Attributes
FourVectorHLTOffline Class Reference

#include <FourVectorHLTOffline.h>

Inheritance diagram for FourVectorHLTOffline:
edm::EDAnalyzer edm::EDConsumerBase

Classes

class  PathInfo
 
class  PathInfoCollection
 

Public Member Functions

void cleanDRMatchSet (mmset &tempSet)
 Clean DR Match Set. More...
 
 FourVectorHLTOffline (const edm::ParameterSet &)
 
 ~FourVectorHLTOffline ()
 
- Public Member Functions inherited from edm::EDAnalyzer
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzer ()
 
ModuleDescription const & moduleDescription () const
 
std::string workerType () const
 
virtual ~EDAnalyzer ()
 
- Public Member Functions inherited from edm::EDConsumerBase
 EDConsumerBase ()
 
ProductHolderIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
std::vector
< ProductHolderIndexAndSkipBit >
const & 		itemsToGetFromEvent () const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
 
bool registeredToConsume (ProductHolderIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
 
virtual ~EDConsumerBase ()
 

Public Attributes

edm::Handle< reco::BeamSpot > fBeamSpotHandle
 
edm::Handle
< trigger::TriggerEvent > 		fTriggerObj
 
edm::Handle< edm::TriggerResults > fTriggerResults
 
PathInfoCollection hltPaths_
 
PathInfoCollection hltPathsDiagonal_
 

Private Member Functions

virtual void analyze (const edm::Event &, const edm::EventSetup &)
 
virtual void beginJob ()
 
void beginLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)
 
void beginRun (const edm::Run &run, const edm::EventSetup &c)
 
void countHLTGroupBXHitsEndLumiBlock (const int &lumi)
 
void countHLTGroupHitsEndLumiBlock (const int &lumi)
 
void countHLTGroupL1HitsEndLumiBlock (const int &lumi)
 
void countHLTPathHitsEndLumiBlock (const int &lumi)
 
virtual void endJob ()
 
void endLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)
 
void endRun (const edm::Run &run, const edm::EventSetup &c)
 EndRun. More...
 
void fillHltMatrix (const edm::TriggerNames &triggerNames)
 
int getHltThresholdFromName (const std::string &pathname)
 
const std::string getL1ConditionModuleName (const std::string &pathname)
 
int getTriggerTypeParsePathName (const std::string &pathname)
 
bool hasHLTPassed (const std::string &pathname, const edm::TriggerNames &triggerNames)
 
bool hasL1Passed (const std::string &pathname, const edm::TriggerNames &triggerNames)
 
bool isVBTFMuon (const reco::Muon &muon)
 
std::string removeVersions (std::string histVersion)
 
void selectElectrons (const edm::Event &iEvent, const edm::EventSetup &iSetup, const edm::Handle< reco::GsfElectronCollection > &eleHandle)
 
void selectJets (const edm::Event &iEvent, const edm::Handle< reco::CaloJetCollection > &jetHandle)
 
void selectMet (const edm::Handle< reco::CaloMETCollection > &metHandle)
 
void selectMuons (const edm::Handle< reco::MuonCollection > &muonHandle)
 
void selectPhotons (const edm::Handle< reco::PhotonCollection > &phoHandle)
 
void selectTaus (const edm::Event &iEvent)
 
void setupHltBxPlots ()
 
void setupHltLsPlots ()
 
void setupHltMatrix (const std::string &label, std::vector< std::string > &paths)
 

Private Attributes

edm::EDGetTokenT< reco::BeamSpot > beamSpotToken
 
double bjetDRMatch_
 
double bjetEtaMax_
 
double bjetEtMin_
 
double bjetL1DRMatch_
 
int currentRun_
 
std::vector< std::pair
< std::string, std::string > > 		custompathnamepairs_
 
DQMStore * dbe_
 
float deltaEtaSuperClusterTrackAtVtxEB_
 
float deltaEtaSuperClusterTrackAtVtxEC_
 
float deltaPhiSuperClusterTrackAtVtxEB_
 
float deltaPhiSuperClusterTrackAtVtxEC_
 
std::string dirname_
 
bool doCombineRuns_
 
float dr03TkSumPtEB_
 
float dr03TkSumPtEC_
 
float dr04EcalRecHitSumEtEB_
 
float dr04EcalRecHitSumEtEC_
 
float dr04HcalTowerSumEtEB_
 
float dr04HcalTowerSumEtEC_
 
double dRMax_
 
double dxyCut_
 
double electronDRMatch_
 
double electronEtaMax_
 
double electronEtMin_
 
double electronL1DRMatch_
 
float eleMaxOver3x3_
 
float emEnergyFractionJet_
 
std::string fCustomBXPath
 
std::vector< std::pair
< std::string, float > > 		fGroupL1TempCountPair
 
std::vector< std::string > fGroupName
 
std::vector< std::pair
< std::string, std::vector
< std::string > > > 		fGroupNamePathsPair
 
std::vector< std::pair
< std::string, float > > 		fGroupTempCountPair
 
float fHPDJet_
 
bool fIsSetup
 
bool fLumiFlag
 
std::vector< std::pair
< std::string, std::vector
< int > > > 		fPathBxTempCountPair
 
std::vector< std::pair
< std::string, float > > 		fPathTempCountPair
 
reco::GsfElectronCollection * fSelectedElectrons
 
reco::CaloJetCollection * fSelectedJets
 
reco::CaloMETCollection * fSelectedMet
 
reco::MuonCollection * fSelectedMuons
 
reco::PhotonCollection * fSelectedPhotons
 
reco::PFTauCollection * fSelectedTaus
 
edm::Handle
< reco::GsfElectronCollection > 		fSelElectronsHandle
 
edm::Handle
< reco::CaloJetCollection > 		fSelJetsHandle
 
edm::Handle
< reco::CaloMETCollection > 		fSelMetHandle
 
edm::Handle< reco::MuonCollection > fSelMuonsHandle
 
edm::Handle
< reco::PhotonCollection > 		fSelPhotonsHandle
 
edm::Handle
< reco::PFTauCollection > 		fSelTausHandle
 
edm::EDGetTokenT
< reco::GsfElectronCollection > 		gsfElectronToken
 
float hadronicOverEmEB_
 
float hadronicOverEmEC_
 
HLTConfigProvider hltConfig_
 
edm::EDGetTokenT< std::vector
< reco::PFTau > > 		hpsPFTauProdToken
 
double htDRMatch_
 
double htEtaMax_
 
double htL1DRMatch_
 
double htMin_
 
edm::EDGetTokenT
< reco::CaloJetCollection > 		iC5calojetToken
 
bool isAlsoTrackerMuon_
 
double jetDRMatch_
 
double jetEtaMax_
 
double jetEtMin_
 
reco::helper::JetIDHelper * jetID
 
double jetL1DRMatch_
 
edm::EDGetTokenT
< reco::JetTagCollection > 		jlipBtagToken
 
double LSsize_
 
MonitorElement * ME_HLT_BX
 
MonitorElement * ME_HLT_CUSTOM_BX
 
MonitorElement * ME_HLTAll_LS
 
double metDRMatch_
 
double metEtaMax_
 
double metL1DRMatch_
 
double metMin_
 
edm::EDGetTokenT
< reco::CaloMETCollection > 		METToken
 
bool monitorDaemon_
 
double muonDRMatch_
 
double muonEtaMax_
 
double muonEtMin_
 
int muonHitsCut_
 
double muonL1DRMatch_
 
std::string muonRecoCollectionName_
 
edm::EDGetTokenT
< reco::MuonCollection > 		muonRecoCollectionToken
 
int n90Jet_
 
unsigned int nBins2D_
 
unsigned int nBins_
 
unsigned int nBinsDR_
 
unsigned int nBinsOneOverEt_
 
unsigned int Nbx_
 
int nev_
 
unsigned int nLS_
 
int nMatchesCut_
 
double normalizedChi2Cut_
 
std::string pathsIndividualHLTPathsPerLSFolder_
 
std::string pathsSummaryFilterCountsFolder_
 
std::string pathsSummaryFilterEfficiencyFolder_
 
std::string pathsSummaryFolder_
 
std::string pathsSummaryHLTCorrelationsFolder_
 
std::string pathsSummaryHLTPathsPerBXFolder_
 
std::string pathsSummaryHLTPathsPerLSFolder_
 
double photonDRMatch_
 
double photonEtaMax_
 
double photonEtMin_
 
double photonL1DRMatch_
 
edm::EDGetTokenT
< reco::PhotonCollection > 		photonToken
 
int pixelHitsCut_
 
edm::EDGetTokenT
< reco::TrackCollection > 		pixelTrackToken
 
bool plotAll_
 
std::string processname_
 
double ptMax_
 
double ptMin_
 
edm::InputTag recHitsEBTag_
 
edm::EDGetTokenT
< edm::SortedCollection
< EcalRecHit > > 		recHitsEBToken
 
edm::InputTag recHitsEETag_
 
edm::EDGetTokenT
< edm::SortedCollection
< EcalRecHit > > 		recHitsEEToken
 
unsigned int referenceBX_
 
MonitorElement * scalersSelect
 
float sigmaIetaIetaEB_
 
float sigmaIetaIetaEC_
 
float sigmaIetaIetaSpikesEB_
 
float sigmaIetaIetaSpikesEC_
 
edm::EDGetTokenT
< reco::JetTagCollection > 		softMuBtagToken
 
std::vector< std::string > specialPaths_
 
double sumEtMin_
 
double tauDRMatch_
 
edm::EDGetTokenT
< reco::PFTauDiscriminator > 		tauDscrmtr1Token
 
edm::EDGetTokenT
< reco::PFTauDiscriminator > 		tauDscrmtr2Token
 
edm::EDGetTokenT
< reco::PFTauDiscriminator > 		tauDscrmtr3Token
 
std::string tauDscrmtrLabel1_
 
std::string tauDscrmtrLabel2_
 
std::string tauDscrmtrLabel3_
 
double tauEtaMax_
 
double tauEtMin_
 
double tauL1DRMatch_
 
edm::EDGetTokenT< std::vector
< reco::PFTau > > 		tauProdToken
 
int theHLTOutputType
 
double thresholdFactor_
 
double trackDRMatch_
 
int trackerHitsCut_
 
double trackEtaMax_
 
double trackEtMin_
 
double trackL1DRMatch_
 
std::vector< std::vector< uint > > triggerFilterIndices_
 
std::vector< std::vector
< std::string > > 		triggerFilters_
 
edm::EDGetTokenT
< edm::TriggerResults > 		triggerResultsFUToken
 
edm::InputTag triggerResultsLabel_
 
edm::EDGetTokenT
< edm::TriggerResults > 		triggerResultsToken
 
edm::EDGetTokenT
< trigger::TriggerEvent > 		triggerSummaryFUToken
 
edm::InputTag triggerSummaryLabel_
 
edm::EDGetTokenT
< trigger::TriggerEvent > 		triggerSummaryToken
 
bool useUM
 
std::vector< MonitorElement * > v_ME_HLTAll_LS
 
std::vector< MonitorElement * > v_ME_Total_BX
 
std::vector< MonitorElement * > v_ME_Total_BX_Norm
 

Additional Inherited Members

- Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer ModuleType
 
- Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &)
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

Detailed Description

Description: This is a DQM source meant to plot high-level HLT trigger quantities as stored in the HLT results object TriggerResults

Implementation: <Notes on="" implementation>="">

Definition at line 113 of file FourVectorHLTOffline.h.

Constructor & Destructor Documentation

FourVectorHLTOffline::FourVectorHLTOffline ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 14 of file FourVectorHLTOffline.cc.

References beamSpotToken, bjetDRMatch_, bjetEtaMax_, bjetEtMin_, bjetL1DRMatch_, DQMStore::book1D(), edm::EDConsumerBase::consumesCollector(), custompathnamepairs_, dbe_, deltaEtaSuperClusterTrackAtVtxEB_, deltaEtaSuperClusterTrackAtVtxEC_, deltaPhiSuperClusterTrackAtVtxEB_, deltaPhiSuperClusterTrackAtVtxEC_, dirname_, doCombineRuns_, dr03TkSumPtEB_, dr03TkSumPtEC_, dr04EcalRecHitSumEtEB_, dr04EcalRecHitSumEtEC_, dr04HcalTowerSumEtEB_, dr04HcalTowerSumEtEC_, dRMax_, dxyCut_, electronDRMatch_, electronEtaMax_, electronEtMin_, electronL1DRMatch_, eleMaxOver3x3_, emEnergyFractionJet_, fCustomBXPath, fHPDJet_, fIsSetup, fLumiFlag, fSelectedElectrons, fSelectedJets, fSelectedMet, fSelectedMuons, fSelectedPhotons, fSelectedTaus, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), gsfElectronToken, hadronicOverEmEB_, hadronicOverEmEC_, hltPaths_, hpsPFTauProdToken, htDRMatch_, htEtaMax_, htL1DRMatch_, htMin_, iC5calojetToken, edm::InputTag::instance(), isAlsoTrackerMuon_, jetDRMatch_, jetEtaMax_, jetEtMin_, jetID, jetL1DRMatch_, jlipBtagToken, edm::InputTag::label(), LogDebug, LSsize_, ME_HLT_BX, ME_HLT_CUSTOM_BX, ME_HLTAll_LS, metDRMatch_, metEtaMax_, metL1DRMatch_, metMin_, METToken, muonDRMatch_, muonEtaMax_, muonEtMin_, muonHitsCut_, muonL1DRMatch_, muonRecoCollectionToken, n90Jet_, nBins2D_, nBins_, nBinsDR_, nBinsOneOverEt_, Nbx_, nLS_, nMatchesCut_, normalizedChi2Cut_, NULL, cppFunctionSkipper::operator, EgammaValidation_cff::paths, pathsSummaryFilterCountsFolder_, pathsSummaryFolder_, pathsSummaryHLTCorrelationsFolder_, pathsSummaryHLTPathsPerLSFolder_, photonDRMatch_, photonEtaMax_, photonEtMin_, photonL1DRMatch_, photonToken, pixelHitsCut_, pixelTrackToken, plotAll_, processname_, ptMax_, ptMin_, recHitsEBTag_, recHitsEBToken, recHitsEETag_, recHitsEEToken, referenceBX_, scalersSelect, DQMStore::setCurrentFolder(), DQMStore::setVerbose(), sigmaIetaIetaEB_, sigmaIetaIetaEC_, sigmaIetaIetaSpikesEB_, sigmaIetaIetaSpikesEC_, softMuBtagToken, specialPaths_, AlCaHLTBitMon_QueryRunRegistry::string, sumEtMin_, tauDRMatch_, tauDscrmtr1Token, tauDscrmtr2Token, tauDscrmtr3Token, tauEtaMax_, tauEtMin_, tauL1DRMatch_, tauProdToken, thresholdFactor_, trackDRMatch_, trackerHitsCut_, trackEtaMax_, trackEtMin_, trackL1DRMatch_, triggerResultsFUToken, triggerResultsLabel_, triggerResultsToken, triggerSummaryFUToken, triggerSummaryLabel_, triggerSummaryToken, and useUM.

14  : currentRun_(-99)
15 {
16 
17  LogDebug("FourVectorHLTOffline") << "constructor...." ;
18 
19  useUM = false;
20  fIsSetup = false;
21  fSelectedMuons = new reco::MuonCollection;
22  fSelectedElectrons = new reco::GsfElectronCollection;
23  fSelectedPhotons = new reco::PhotonCollection;
24  fSelectedJets = new reco::CaloJetCollection;
25  fSelectedMet = new reco::CaloMETCollection;
26  //fSelectedTaus = new reco::CaloTauCollection;
27  fSelectedTaus = new reco::PFTauCollection;
28 
29  dbe_ = Service < DQMStore > ().operator->();
30  if ( ! dbe_ ) {
31  LogInfo("FourVectorHLTOffline") << "unabel to get DQMStore service?";
32  }
33  if (iConfig.getUntrackedParameter < bool > ("DQMStore", false)) {
34  dbe_->setVerbose(0);
35  }
36 
37  dirname_ = iConfig.getUntrackedParameter("dirname", std::string("HLT/FourVector/"));
38  //dirname_ += iConfig.getParameter<std::string>("@module_label");
39 
40  if (dbe_ != 0 ) {
41  dbe_->setCurrentFolder(dirname_);
42  }
43 
44 
45  doCombineRuns_ = iConfig.getUntrackedParameter<bool>("doCombineRuns", false);
46 
47  processname_ = iConfig.getParameter<std::string>("processname");
48  fCustomBXPath = iConfig.getUntrackedParameter<std::string>("customBXPath", std::string("HLT_MinBiasBSC"));
49 
50  referenceBX_ = iConfig.getUntrackedParameter<unsigned int>("referenceBX",51);
51  Nbx_ = iConfig.getUntrackedParameter<unsigned int>("Nbx",3564);
52 
53  // plotting paramters
54  ptMin_ = iConfig.getUntrackedParameter<double>("ptMin",0.);
55  ptMax_ = iConfig.getUntrackedParameter<double>("ptMax",1000.);
56  nBins_ = iConfig.getUntrackedParameter<unsigned int>("Nbins",20);
57  nBins2D_ = iConfig.getUntrackedParameter<unsigned int>("Nbins2D",40);
58  dRMax_ = iConfig.getUntrackedParameter<double>("dRMax",1.0);
59  nBinsDR_ = iConfig.getUntrackedParameter<unsigned int>("NbinsDR",10);
60  nBinsOneOverEt_ = iConfig.getUntrackedParameter<unsigned int>("NbinsOneOverEt",10000);
61  nLS_ = iConfig.getUntrackedParameter<unsigned int>("NLuminositySegments",10);
62  LSsize_ = iConfig.getUntrackedParameter<double>("LuminositySegmentSize",23);
63  thresholdFactor_ = iConfig.getUntrackedParameter<double>("thresholdFactor",1.5);
64 
65 
66  plotAll_ = iConfig.getUntrackedParameter<bool>("plotAll", false);
67  // this is the list of paths to look at.
68  std::vector<edm::ParameterSet> paths =
69  iConfig.getParameter<std::vector<edm::ParameterSet> >("paths");
70 
71  for(std::vector<edm::ParameterSet>::iterator pathconf = paths.begin() ; pathconf != paths.end(); pathconf++) {
72 
73  //std::pair<std::string, std::string> custompathnamepair;
74  //custompathnamepair.first =pathconf->getParameter<std::string>("pathname");
75  //custompathnamepair.second = pathconf->getParameter<std::string>("denompathname");
76  //custompathnamepairs_.push_back(custompathnamepair);
77  custompathnamepairs_.push_back(
78  make_pair(
79  pathconf->getParameter<std::string>("pathname"),
80  pathconf->getParameter<std::string>("denompathname")
81  )
82  );
83 
84  }
85 
86  if (hltPaths_.size() > 0)
87  {
88  // book a histogram of scalers
89  scalersSelect = dbe_->book1D("selectedScalers","Selected Scalers", hltPaths_.size(), 0.0, (double)hltPaths_.size());
90 
91  }
92 
93  triggerSummaryLabel_ = iConfig.getParameter<edm::InputTag>("triggerSummaryLabel");
94  triggerResultsLabel_ = iConfig.getParameter<edm::InputTag>("triggerResultsLabel");
95  triggerSummaryToken = consumes <trigger::TriggerEvent> (triggerSummaryLabel_);
96  triggerResultsToken = consumes <TriggerResults> (triggerResultsLabel_);
97  triggerSummaryFUToken = consumes <trigger::TriggerEvent> (edm::InputTag(triggerSummaryLabel_.label(),triggerSummaryLabel_.instance(),std::string("FU")));
98  triggerResultsFUToken = consumes <TriggerResults> (edm::InputTag(triggerResultsLabel_.label(),triggerResultsLabel_.instance(),std::string("FU")));
99  muonRecoCollectionToken = consumes <reco::MuonCollection> (iConfig.getUntrackedParameter("muonRecoCollectionName", std::string("muons")));
100 
101  beamSpotToken = consumes <reco::BeamSpot> (std::string("offlineBeamSpot"));
102  gsfElectronToken = consumes <reco::GsfElectronCollection> (std::string("gsfElectrons"));
103  tauProdToken = consumes <std::vector<reco::PFTau> > (std::string("caloRecoTauProducer"));
104  iC5calojetToken = consumes <reco::CaloJetCollection> (std::string("iterativeCone5CaloJets"));
105  jlipBtagToken = consumes <reco::JetTagCollection> (std::string("jetProbabilityBJetTags"));
106  softMuBtagToken = consumes <reco::JetTagCollection> (std::string("softMuonBJetTags"));
107  METToken = consumes <reco::CaloMETCollection> (std::string("met"));
108  photonToken = consumes <reco::PhotonCollection> (std::string("photons"));
109  pixelTrackToken = consumes <reco::TrackCollection> (std::string("pixelTracks"));
110  hpsPFTauProdToken = consumes <std::vector<reco::PFTau> > (std::string("hpsPFTauProducer"));
111 
112  electronEtaMax_ = iConfig.getUntrackedParameter<double>("electronEtaMax",2.5);
113  electronEtMin_ = iConfig.getUntrackedParameter<double>("electronEtMin",3.0);
114  electronDRMatch_ =iConfig.getUntrackedParameter<double>("electronDRMatch",0.3);
115  electronL1DRMatch_ =iConfig.getUntrackedParameter<double>("electronL1DRMatch",0.3);
116 
117  muonEtaMax_ = iConfig.getUntrackedParameter<double>("muonEtaMax",2.1);
118  muonEtMin_ = iConfig.getUntrackedParameter<double>("muonEtMin",3.0);
119  muonDRMatch_ =iConfig.getUntrackedParameter<double>("muonDRMatch",0.3);
120  muonL1DRMatch_ =iConfig.getUntrackedParameter<double>("muonL1DRMatch",0.3);
121 
122  tauEtaMax_ = iConfig.getUntrackedParameter<double>("tauEtaMax",2.5);
123  tauEtMin_ = iConfig.getUntrackedParameter<double>("tauEtMin",3.0);
124  tauDRMatch_ =iConfig.getUntrackedParameter<double>("tauDRMatch",0.3);
125  tauL1DRMatch_ =iConfig.getUntrackedParameter<double>("tauL1DRMatch",0.5);
126 
127  jetEtaMax_ = iConfig.getUntrackedParameter<double>("jetEtaMax",5.0);
128  jetEtMin_ = iConfig.getUntrackedParameter<double>("jetEtMin",10.0);
129  jetDRMatch_ =iConfig.getUntrackedParameter<double>("jetDRMatch",0.3);
130  jetL1DRMatch_ =iConfig.getUntrackedParameter<double>("jetL1DRMatch",0.5);
131 
132  bjetEtaMax_ = iConfig.getUntrackedParameter<double>("bjetEtaMax",2.5);
133  bjetEtMin_ = iConfig.getUntrackedParameter<double>("bjetEtMin",10.0);
134  bjetDRMatch_ =iConfig.getUntrackedParameter<double>("bjetDRMatch",0.3);
135  bjetL1DRMatch_ =iConfig.getUntrackedParameter<double>("bjetL1DRMatch",0.3);
136 
137  photonEtaMax_ = iConfig.getUntrackedParameter<double>("photonEtaMax",2.5);
138  photonEtMin_ = iConfig.getUntrackedParameter<double>("photonEtMin",3.0);
139  photonDRMatch_ =iConfig.getUntrackedParameter<double>("photonDRMatch",0.3);
140  photonL1DRMatch_ =iConfig.getUntrackedParameter<double>("photonL1DRMatch",0.3);
141 
142  trackEtaMax_ = iConfig.getUntrackedParameter<double>("trackEtaMax",2.5);
143  trackEtMin_ = iConfig.getUntrackedParameter<double>("trackEtMin",3.0);
144  trackDRMatch_ =iConfig.getUntrackedParameter<double>("trackDRMatch",0.3);
145  trackL1DRMatch_ =iConfig.getUntrackedParameter<double>("trackL1DRMatch",0.3);
146 
147  metEtaMax_ = iConfig.getUntrackedParameter<double>("metEtaMax",5);
148  metMin_ = iConfig.getUntrackedParameter<double>("metMin",10.0);
149  metDRMatch_ =iConfig.getUntrackedParameter<double>("metDRMatch",0.5);
150  metL1DRMatch_ =iConfig.getUntrackedParameter<double>("metL1DRMatch",0.5);
151 
152  htEtaMax_ = iConfig.getUntrackedParameter<double>("htEtaMax",5);
153  htMin_ = iConfig.getUntrackedParameter<double>("htMin",10.0);
154  htDRMatch_ =iConfig.getUntrackedParameter<double>("htDRMatch",0.5);
155  htL1DRMatch_ =iConfig.getUntrackedParameter<double>("htL1DRMatch",0.5);
156 
157  sumEtMin_ = iConfig.getUntrackedParameter<double>("sumEtMin",10.0);
158 
159  // Muon quality cuts
161  dxyCut_ = iConfig.getUntrackedParameter<double>("DxyCut", 0.2); // dxy < 0.2 cm
162  normalizedChi2Cut_ = iConfig.getUntrackedParameter<double>("NormalizedChi2Cut", 10.); // chi2/ndof (of global fit) <10.0
163  trackerHitsCut_ = iConfig.getUntrackedParameter<int>("TrackerHitsCut", 11); // Tracker Hits >10
164  pixelHitsCut_ = iConfig.getUntrackedParameter<int>("PixelHitsCut", 1); // Pixel Hits >0
165  muonHitsCut_ = iConfig.getUntrackedParameter<int>("MuonHitsCut", 1); // Valid Muon Hits >0
166  isAlsoTrackerMuon_ = iConfig.getUntrackedParameter<bool>("IsAlsoTrackerMuon", true);
167  nMatchesCut_ = iConfig.getUntrackedParameter<int>("NMatchesCut", 2); // At least 2 Chambers with matches
168 
169  // Electron quality cuts
171  eleMaxOver3x3_ = iConfig.getUntrackedParameter<double>("eleMaxOver3x3", 0.9);
172  // Ecal Barrel
173  dr03TkSumPtEB_ = iConfig.getUntrackedParameter<double>("dr03TkSumPtEB", 3.0);
174  dr04EcalRecHitSumEtEB_ = iConfig.getUntrackedParameter<double>("dr04EcalRecHitSumEtEB", 4.0);
175  dr04HcalTowerSumEtEB_ = iConfig.getUntrackedParameter<double>("dr04HcalTowerSumEtEB", 5.0);
176  hadronicOverEmEB_ = iConfig.getUntrackedParameter<double>("hadronicOverEmEB", 0.05);
177  deltaPhiSuperClusterTrackAtVtxEB_ = iConfig.getUntrackedParameter<double>("deltaPhiSuperClusterTrackAtVtxEB", 0.2);
178  deltaEtaSuperClusterTrackAtVtxEB_ = iConfig.getUntrackedParameter<double>("deltaEtaSuperClusterTrackAtVtxEB", 0.006);
179  sigmaIetaIetaEB_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaEB", 0.01);
180  //spikes
181  sigmaIetaIetaSpikesEB_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaSpikesEB", 0.002);
182 
183  // Ecal Endcap
184  dr03TkSumPtEC_ = iConfig.getUntrackedParameter<double>("dr03TkSumPtEC", 1.5);
185  dr04EcalRecHitSumEtEC_ = iConfig.getUntrackedParameter<double>("dr04EcalRecHitSumEtEC", 2.5);
186  dr04HcalTowerSumEtEC_ = iConfig.getUntrackedParameter<double>("dr04HcalTowerSumEtEC", 0.7);
187  hadronicOverEmEC_ = iConfig.getUntrackedParameter<double>("hadronicOverEmEC", 0.025);
188  deltaPhiSuperClusterTrackAtVtxEC_ = iConfig.getUntrackedParameter<double>("deltaPhiSuperClusterTrackAtVtxEC", 0.2);
189  deltaEtaSuperClusterTrackAtVtxEC_ = iConfig.getUntrackedParameter<double>("deltaEtaSuperClusterTrackAtVtxEC", 0.006);
190  sigmaIetaIetaEC_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaEC", 0.03);
191  //spikes
192  sigmaIetaIetaSpikesEC_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaSpikesEC", 0.002);
193 
194  // Jet ID cuts
196  emEnergyFractionJet_ = iConfig.getUntrackedParameter<double>("emEnergyFractionJet",0.01);
197  fHPDJet_ = iConfig.getUntrackedParameter<double>("fHPDJet",0.98);
198  n90Jet_ = iConfig.getUntrackedParameter<int>("n90Jet",2);
199 
200  // Tau discriminators
202  tauDscrmtr1Token = consumes <reco::PFTauDiscriminator> (iConfig.getUntrackedParameter("tauDscrmtrLabel1", std::string("shrinkingConePFTauDiscriminationByLeadingTrackFinding")));
203  tauDscrmtr2Token = consumes <reco::PFTauDiscriminator> (iConfig.getUntrackedParameter("tauDscrmtrLabel2", std::string("shrinkingConePFTauDiscriminationByLeadingTrackPtCut")));
204  tauDscrmtr3Token = consumes <reco::PFTauDiscriminator> (iConfig.getUntrackedParameter("tauDscrmtrLabel3", std::string("shrinkingConePFTauDiscriminationByIsolation")));
205 
206  specialPaths_ = iConfig.getParameter<std::vector<std::string > >("SpecialPaths");
207 
208  pathsSummaryFolder_ = iConfig.getUntrackedParameter ("pathsSummaryFolder",std::string("HLT/FourVector/PathsSummary/"));
209  pathsSummaryHLTCorrelationsFolder_ = iConfig.getUntrackedParameter ("hltCorrelationsFolder",std::string("HLT/FourVector/PathsSummary/HLT Correlations/"));
210  pathsSummaryFilterCountsFolder_ = iConfig.getUntrackedParameter ("filterCountsFolder",std::string("HLT/FourVector/PathsSummary/Filters Counts/"));
211 
212  pathsSummaryHLTPathsPerLSFolder_ = iConfig.getUntrackedParameter ("pathsPerLSFolder",std::string("HLT/FourVector/PathsSummary/HLT LS/"));
213  // pathsIndividualHLTPathsPerLSFolder_ = iConfig.getUntrackedParameter ("individualPathsPerLSFolder",std::string("HLT/FourVector/PathsSummary/HLT LS/Paths/"));
214  // pathsSummaryHLTPathsPerBXFolder_ = iConfig.getUntrackedParameter ("individualPathsPerBXFolder",std::string("HLT/FourVector/PathsSummary/HLT BX/"));
215 
216  fLumiFlag = true;
217  ME_HLTAll_LS = NULL;
218  ME_HLT_BX = NULL;
219  ME_HLT_CUSTOM_BX = NULL;
220 
221  jetID = new reco::helper::JetIDHelper(iConfig.getParameter<ParameterSet>("JetIDParams"), consumesCollector());
222 
223  recHitsEBTag_ = iConfig.getUntrackedParameter<edm::InputTag>("RecHitsEBTag",edm::InputTag("reducedEcalRecHitsEB"));
224  recHitsEETag_ = iConfig.getUntrackedParameter<edm::InputTag>("RecHitsEETag",edm::InputTag("reducedEcalRecHitsEE"));
225  recHitsEBToken = consumes <edm::SortedCollection<EcalRecHit> > (recHitsEBTag_);
226  recHitsEEToken = consumes <edm::SortedCollection<EcalRecHit> > (recHitsEETag_);
227 
228 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
FourVectorHLTOffline::jetID
reco::helper::JetIDHelper * jetID
Definition: FourVectorHLTOffline.h:171
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
reco::PFTauCollection
std::vector< PFTau > PFTauCollection
collection of PFTau objects
Definition: PFTauFwd.h:9
EgammaValidation_cff.paths
tuple paths
Definition: EgammaValidation_cff.py:18
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:928
FourVectorHLTOffline::fSelectedMet
reco::CaloMETCollection * fSelectedMet
Definition: FourVectorHLTOffline.h:208
FourVectorHLTOffline::hltPaths_
PathInfoCollection hltPaths_
Definition: FourVectorHLTOffline.h:720
FourVectorHLTOffline::fSelectedTaus
reco::PFTauCollection * fSelectedTaus
Definition: FourVectorHLTOffline.h:213
FourVectorHLTOffline::tauDscrmtr1Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr1Token
Definition: FourVectorHLTOffline.h:346
FourVectorHLTOffline::pathsSummaryHLTPathsPerLSFolder_
std::string pathsSummaryHLTPathsPerLSFolder_
Definition: FourVectorHLTOffline.h:189
FourVectorHLTOffline::recHitsEBToken
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit > > recHitsEBToken
Definition: FourVectorHLTOffline.h:343
FourVectorHLTOffline::specialPaths_
std::vector< std::string > specialPaths_
Definition: FourVectorHLTOffline.h:322
NULL
#define NULL
Definition: scimark2.h:8
FourVectorHLTOffline::gsfElectronToken
edm::EDGetTokenT< reco::GsfElectronCollection > gsfElectronToken
Definition: FourVectorHLTOffline.h:335
FourVectorHLTOffline::triggerResultsToken
edm::EDGetTokenT< edm::TriggerResults > triggerResultsToken
Definition: FourVectorHLTOffline.h:329
FourVectorHLTOffline::tauDscrmtr2Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr2Token
Definition: FourVectorHLTOffline.h:347
reco::GsfElectronCollection
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
Definition: GsfElectronFwd.h:14
FourVectorHLTOffline::triggerSummaryLabel_
edm::InputTag triggerSummaryLabel_
Definition: FourVectorHLTOffline.h:350
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
FourVectorHLTOffline::custompathnamepairs_
std::vector< std::pair< std::string, std::string > > custompathnamepairs_
Definition: FourVectorHLTOffline.h:312
reco::MuonCollection
std::vector< Muon > MuonCollection
collection of Muon objects
Definition: MuonFwd.h:9
FourVectorHLTOffline::fSelectedElectrons
reco::GsfElectronCollection * fSelectedElectrons
Definition: FourVectorHLTOffline.h:199
FourVectorHLTOffline::triggerSummaryFUToken
edm::EDGetTokenT< trigger::TriggerEvent > triggerSummaryFUToken
Definition: FourVectorHLTOffline.h:332
FourVectorHLTOffline::pixelTrackToken
edm::EDGetTokenT< reco::TrackCollection > pixelTrackToken
Definition: FourVectorHLTOffline.h:342
FourVectorHLTOffline::photonToken
edm::EDGetTokenT< reco::PhotonCollection > photonToken
Definition: FourVectorHLTOffline.h:341
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:67
FourVectorHLTOffline::tauProdToken
edm::EDGetTokenT< std::vector< reco::PFTau > > tauProdToken
Definition: FourVectorHLTOffline.h:336
FourVectorHLTOffline::beamSpotToken
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken
Definition: FourVectorHLTOffline.h:333
FourVectorHLTOffline::triggerSummaryToken
edm::EDGetTokenT< trigger::TriggerEvent > triggerSummaryToken
Definition: FourVectorHLTOffline.h:331
FourVectorHLTOffline::iC5calojetToken
edm::EDGetTokenT< reco::CaloJetCollection > iC5calojetToken
Definition: FourVectorHLTOffline.h:337
DQMStore::setVerbose
void setVerbose(unsigned level)
Definition: DQMStore.cc:603
FourVectorHLTOffline::fSelectedPhotons
reco::PhotonCollection * fSelectedPhotons
Definition: FourVectorHLTOffline.h:202
FourVectorHLTOffline::ME_HLT_BX
MonitorElement * ME_HLT_BX
Definition: FourVectorHLTOffline.h:179
FourVectorHLTOffline::muonRecoCollectionToken
edm::EDGetTokenT< reco::MuonCollection > muonRecoCollectionToken
Definition: FourVectorHLTOffline.h:334
FourVectorHLTOffline::fSelectedMuons
reco::MuonCollection * fSelectedMuons
Definition: FourVectorHLTOffline.h:196
FourVectorHLTOffline::triggerResultsLabel_
edm::InputTag triggerResultsLabel_
Definition: FourVectorHLTOffline.h:351
FourVectorHLTOffline::tauDscrmtr3Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr3Token
Definition: FourVectorHLTOffline.h:348
FourVectorHLTOffline::METToken
edm::EDGetTokenT< reco::CaloMETCollection > METToken
Definition: FourVectorHLTOffline.h:340
reco::CaloMETCollection
std::vector< reco::CaloMET > CaloMETCollection
collection of CaloMET objects
Definition: CaloMETCollection.h:21
FourVectorHLTOffline::hpsPFTauProdToken
edm::EDGetTokenT< std::vector< reco::PFTau > > hpsPFTauProdToken
Definition: FourVectorHLTOffline.h:345
FourVectorHLTOffline::ME_HLT_CUSTOM_BX
MonitorElement * ME_HLT_CUSTOM_BX
Definition: FourVectorHLTOffline.h:180
reco::PhotonCollection
std::vector< Photon > PhotonCollection
collectin of Photon objects
Definition: PhotonFwd.h:9
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:42
FourVectorHLTOffline::jlipBtagToken
edm::EDGetTokenT< reco::JetTagCollection > jlipBtagToken
Definition: FourVectorHLTOffline.h:338
FourVectorHLTOffline::pathsSummaryHLTCorrelationsFolder_
std::string pathsSummaryHLTCorrelationsFolder_
Definition: FourVectorHLTOffline.h:186
FourVectorHLTOffline::pathsSummaryFilterCountsFolder_
std::string pathsSummaryFilterCountsFolder_
Definition: FourVectorHLTOffline.h:188
FourVectorHLTOffline::softMuBtagToken
edm::EDGetTokenT< reco::JetTagCollection > softMuBtagToken
Definition: FourVectorHLTOffline.h:339
FourVectorHLTOffline::ME_HLTAll_LS
MonitorElement * ME_HLTAll_LS
Definition: FourVectorHLTOffline.h:178
FourVectorHLTOffline::recHitsEEToken
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit > > recHitsEEToken
Definition: FourVectorHLTOffline.h:344
FourVectorHLTOffline::triggerResultsFUToken
edm::EDGetTokenT< edm::TriggerResults > triggerResultsFUToken
Definition: FourVectorHLTOffline.h:330
FourVectorHLTOffline::fSelectedJets
reco::CaloJetCollection * fSelectedJets
Definition: FourVectorHLTOffline.h:205
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:43
FourVectorHLTOffline::scalersSelect
MonitorElement * scalersSelect
Definition: FourVectorHLTOffline.h:357
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:639
reco::CaloJetCollection
std::vector< CaloJet > CaloJetCollection
collection of CaloJet objects
Definition: CaloJetCollection.h:15
FourVectorHLTOffline::~FourVectorHLTOffline ( )

Definition at line 231 of file FourVectorHLTOffline.cc.

References fSelectedElectrons, fSelectedJets, fSelectedMet, fSelectedMuons, fSelectedPhotons, and fSelectedTaus.

232 {
233 
234  // do anything here that needs to be done at desctruction time
235  // (e.g. close files, deallocate resources etc.)
236  delete fSelectedMuons;
237  delete fSelectedElectrons;
238  delete fSelectedPhotons;
239  delete fSelectedJets;
240  delete fSelectedMet;
241  delete fSelectedTaus;
242 
243 }
FourVectorHLTOffline::fSelectedMet
reco::CaloMETCollection * fSelectedMet
Definition: FourVectorHLTOffline.h:208
FourVectorHLTOffline::fSelectedTaus
reco::PFTauCollection * fSelectedTaus
Definition: FourVectorHLTOffline.h:213
FourVectorHLTOffline::fSelectedElectrons
reco::GsfElectronCollection * fSelectedElectrons
Definition: FourVectorHLTOffline.h:199
FourVectorHLTOffline::fSelectedPhotons
reco::PhotonCollection * fSelectedPhotons
Definition: FourVectorHLTOffline.h:202
FourVectorHLTOffline::fSelectedMuons
reco::MuonCollection * fSelectedMuons
Definition: FourVectorHLTOffline.h:196
FourVectorHLTOffline::fSelectedJets
reco::CaloJetCollection * fSelectedJets
Definition: FourVectorHLTOffline.h:205

Member Function Documentation

void FourVectorHLTOffline::analyze ( const edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
privatevirtual

Implements edm::EDAnalyzer.

Definition at line 252 of file FourVectorHLTOffline.cc.

References beamSpotToken, plotTTrigFromHistos::binNumber(), bjetDRMatch_, bjetEtaMax_, bjetEtMin_, bjetL1DRMatch_, BaseMonitor::clearSets(), dRMax_, electronDRMatch_, electronEtaMax_, electronEtMin_, electronL1DRMatch_, fBeamSpotHandle, fillHltMatrix(), BaseMonitor::fillL1Match(), BaseMonitor::fillOnlineMatch(), fSelElectronsHandle, fSelJetsHandle, fSelMetHandle, fSelMuonsHandle, fSelTausHandle, fTriggerObj, fTriggerResults, edm::Event::getByToken(), gsfElectrons_cfi::gsfElectrons, gsfElectronToken, hltConfig_, hltPaths_, hltPathsDiagonal_, i, iC5calojetToken, edm::HandleBase::isValid(), jetDRMatch_, jetEtaMax_, jetEtMin_, jetL1DRMatch_, jlipBtagToken, LogDebug, LogTrace, metDRMatch_, metEtaMax_, metL1DRMatch_, metMin_, METToken, HLTConfigProvider::moduleLabels(), LaserDQM_cfi::mon, BaseMonitor::monitorL1(), BaseMonitor::monitorOffline(), BaseMonitor::monitorOnline(), muonDRMatch_, muonEtaMax_, muonEtMin_, muonL1DRMatch_, muonRecoCollectionToken, nev_, NULL, photonDRMatch_, photonEtaMax_, photonEtMin_, photonL1DRMatch_, photonToken, pixelTrackToken, processname_, selectElectrons(), selectJets(), selectMet(), selectMuons(), selectPhotons(), selectTaus(), objMonData< T >::setLimits(), BaseMonitor::setPath(), objMonData< T >::setReco(), objMonData< T >::setRecoB(), softMuBtagToken, tauDRMatch_, tauEtaMax_, tauEtMin_, tauL1DRMatch_, tauProdToken, thresholdFactor_, trigger::TriggerBJet, trigger::TriggerElectron, trigger::TriggerJet, trigger::TriggerL1CenJet, trigger::TriggerL1ETM, trigger::TriggerL1ETT, trigger::TriggerL1ForJet, trigger::TriggerL1IsoEG, trigger::TriggerL1Mu, trigger::TriggerL1NoIsoEG, trigger::TriggerL1TauJet, trigger::TriggerMET, trigger::TriggerMuon, edm::Event::triggerNames(), trigger::TriggerPhoton, triggerResults, triggerResultsFUToken, triggerResultsToken, triggerSummaryFUToken, triggerSummaryToken, trigger::TriggerTau, trigger::TriggerTET, and findQualityFiles::v.

253 {
254 
255  //if(! fLumiFlag ) return;
256 
257  using namespace edm;
258  using namespace trigger;
259  ++nev_;
260  LogDebug("FourVectorHLTOffline")<< " analyze...." ;
261 
262  edm::Handle<TriggerResults> triggerResults;
263  iEvent.getByToken(triggerResultsToken,triggerResults);
264  if(!triggerResults.isValid()) {
265  iEvent.getByToken(triggerResultsFUToken,triggerResults);
266  if(!triggerResults.isValid()) {
267  edm::LogInfo("FourVectorHLTOffline") << "TriggerResults not found, "
268  "skipping event";
269  return;
270  }
271  }
272  fTriggerResults = triggerResults;
273  const edm::TriggerNames & triggerNames = iEvent.triggerNames(*triggerResults);
274  int npath = triggerResults->size();
275 
276  iEvent.getByToken(triggerSummaryToken,fTriggerObj);
277  if(!fTriggerObj.isValid()) {
278 
279  iEvent.getByToken(triggerSummaryFUToken,fTriggerObj);
280 
281  if(!fTriggerObj.isValid()) {
282 
283  edm::LogInfo("FourVectorHLTOffline") << "TriggerEvent not found, " "skipping event";
284  return;
285 
286  }
287 
288  }
289 
290  // Beam spot
291  if (!iEvent.getByToken(beamSpotToken, fBeamSpotHandle)) {
292  edm::LogInfo("") << ">>> No beam spot found !!!";
293  }
294 
295  edm::Handle<reco::MuonCollection> muonHandle;
296  iEvent.getByToken(muonRecoCollectionToken,muonHandle);
297  if(!muonHandle.isValid())
298  edm::LogInfo("FourVectorHLTOffline") << "muonHandle not found, ";
299  selectMuons(muonHandle);
300 
301  edm::Handle<reco::GsfElectronCollection> gsfElectrons;
302  iEvent.getByToken(gsfElectronToken,gsfElectrons);
303  if(!gsfElectrons.isValid())
304  edm::LogInfo("FourVectorHLTOffline") << "gsfElectrons not found, ";
305  selectElectrons(iEvent, iSetup, gsfElectrons);
306 
307  //edm::Handle<reco::CaloTauCollection> tauHandle;
308  edm::Handle<reco::PFTauCollection> tauHandle;
309  iEvent.getByToken(tauProdToken,tauHandle);
310  if(!tauHandle.isValid())
311  edm::LogInfo("FourVectorHLTOffline") << "tauHandle not found, ";
312  //selectTaus(tauHandle);
313  selectTaus(iEvent);
314 
315  edm::Handle<reco::CaloJetCollection> jetHandle;
316  iEvent.getByToken(iC5calojetToken,jetHandle);
317  if(!jetHandle.isValid())
318  edm::LogInfo("FourVectorHLTOffline") << "jetHandle not found, ";
319  selectJets(iEvent,jetHandle);
320 
321  // Get b tag information
322  edm::Handle<reco::JetTagCollection> bTagIPHandle;
323  iEvent.getByToken(jlipBtagToken, bTagIPHandle);
324  if (!bTagIPHandle.isValid())
325  edm::LogInfo("FourVectorHLTOffline") << "mTagIPHandle trackCountingHighEffJetTags not found, ";
326 
327  // Get b tag information
328  edm::Handle<reco::JetTagCollection> bTagMuHandle;
329  iEvent.getByToken(softMuBtagToken, bTagMuHandle);
330  if (!bTagMuHandle.isValid())
331  edm::LogInfo("FourVectorHLTOffline") << "bTagMuHandle not found, ";
332 
333  edm::Handle<reco::CaloMETCollection> metHandle;
334  iEvent.getByToken(METToken,metHandle);
335  if(!metHandle.isValid())
336  edm::LogInfo("FourVectorHLTOffline") << "metHandle not found, ";
337  selectMet(metHandle);
338 
339  edm::Handle<reco::PhotonCollection> photonHandle;
340  iEvent.getByToken(photonToken,photonHandle);
341  if(!photonHandle.isValid())
342  edm::LogInfo("FourVectorHLTOffline") << "photonHandle not found, ";
343  selectPhotons(photonHandle);
344 
345  edm::Handle<reco::TrackCollection> trackHandle;
346  iEvent.getByToken(pixelTrackToken,trackHandle);
347  if(!trackHandle.isValid())
348  edm::LogInfo("FourVectorHLTOffline") << "trackHandle not found, ";
349 
350 
351  // ---------------------
352  // Monitors
353  // ---------------------
354 
355  // electron Monitor
356  objMonData<reco::GsfElectronCollection> eleMon;
357  //eleMon.setReco(gsfElectrons);
358  eleMon.setReco(fSelElectronsHandle);
359  eleMon.setRecoEle(fSelElectronsHandle);
360  eleMon.setLimits(electronEtaMax_, electronEtMin_, electronDRMatch_, electronL1DRMatch_, dRMax_, thresholdFactor_);
361 
362  eleMon.pushTriggerType(TriggerElectron);
363  eleMon.pushTriggerType(TriggerL1NoIsoEG);
364  eleMon.pushTriggerType(TriggerL1IsoEG);
365 
366  eleMon.pushL1TriggerType(TriggerL1NoIsoEG);
367  eleMon.pushL1TriggerType(TriggerL1IsoEG);
368 
369  // muon Monitor
370  objMonData<reco::MuonCollection> muoMon;
371  //muoMon.setReco(muonHandle);
372  muoMon.setReco(fSelMuonsHandle);
373  muoMon.setRecoMu(fSelMuonsHandle);
374  muoMon.setLimits(muonEtaMax_, muonEtMin_, muonDRMatch_, muonL1DRMatch_, dRMax_, thresholdFactor_);
375 
376  muoMon.pushTriggerType(TriggerMuon);
377  muoMon.pushTriggerType(TriggerL1Mu);
378 
379  muoMon.pushL1TriggerType(TriggerL1Mu);
380 
381  // tau Monitor
382  //objMonData<reco::CaloTauCollection> tauMon;
383  objMonData<reco::PFTauCollection> tauMon;
384  //tauMon.setReco(tauHandle);
385  tauMon.setReco(fSelTausHandle);
386  tauMon.setLimits(tauEtaMax_, tauEtMin_, tauDRMatch_, tauL1DRMatch_, dRMax_, thresholdFactor_);
387 
388  tauMon.pushTriggerType(TriggerTau);
389  tauMon.pushTriggerType(TriggerL1TauJet);
390 
391  tauMon.pushL1TriggerType(TriggerL1TauJet);
392  tauMon.pushL1TriggerType(TriggerL1ForJet);
393 
394  // photon Monitor
395  //objMonData<reco::PhotonCollection> phoMon;
396  //phoMon.setReco(photonHandle);
397  //phoMon.setReco(fSelPhotonsHandle);
398  // -----------------------------------------------
399  // Use RECO Electrons instead of RECO Photons
400  // to measure HLT_Photon efficiency
401  // -----------------------------------------------
402  objMonData<reco::GsfElectronCollection> phoMon;
403  phoMon.setReco(fSelElectronsHandle);
404  phoMon.setRecoEle(fSelElectronsHandle);
405 
406 
407  phoMon.setLimits(photonEtaMax_, photonEtMin_, photonDRMatch_, photonL1DRMatch_, dRMax_, thresholdFactor_);
408 
409  phoMon.pushTriggerType(TriggerPhoton);
410 
411  phoMon.pushL1TriggerType(TriggerL1NoIsoEG);
412  phoMon.pushL1TriggerType(TriggerL1IsoEG);
413 
414  // jet Monitor - NOTICE: we use genJets for MC
415  objMonData<reco::CaloJetCollection> jetMon;
416  //jetMon.setReco(jetHandle);
417  jetMon.setReco(fSelJetsHandle);
418  jetMon.setLimits(jetEtaMax_, jetEtMin_, jetDRMatch_, jetL1DRMatch_, dRMax_, thresholdFactor_);
419 
420  jetMon.pushTriggerType(TriggerJet);
421  jetMon.pushTriggerType(TriggerL1CenJet);
422  jetMon.pushTriggerType(TriggerL1ForJet);
423 
424  jetMon.pushL1TriggerType(TriggerL1CenJet);
425  jetMon.pushL1TriggerType(TriggerL1ForJet);
426  jetMon.pushL1TriggerType(TriggerL1TauJet);
427 
428  // bjet Monitor - NOTICE: we use genJets for MC
429  objMonData<reco::CaloJetCollection> btagIPMon; // CaloJet will not be used, this is only place holder
430  //btagIPMon.setReco(jetHandle);
431  btagIPMon.setRecoB(bTagIPHandle);
432  btagIPMon.setBJetsFlag(true);
433  btagIPMon.setLimits(bjetEtaMax_, bjetEtMin_, bjetDRMatch_, bjetL1DRMatch_, dRMax_, thresholdFactor_);
434 
435  btagIPMon.pushTriggerType(TriggerBJet);
436  btagIPMon.pushTriggerType(TriggerJet);
437 
438  btagIPMon.pushL1TriggerType(TriggerL1CenJet);
439  btagIPMon.pushL1TriggerType(TriggerL1ForJet);
440  btagIPMon.pushL1TriggerType(TriggerL1TauJet);
441 
442  objMonData<reco::CaloJetCollection> btagMuMon; // CaloJet will not be used, this is only place holder
443  //btagMuMon.setReco(jetHandle);
444  btagMuMon.setRecoB(bTagMuHandle);
445  btagMuMon.setBJetsFlag(true);
446  btagMuMon.setLimits(bjetEtaMax_, bjetEtMin_, bjetDRMatch_, bjetL1DRMatch_, dRMax_, thresholdFactor_);
447 
448  btagMuMon.pushTriggerType(TriggerBJet);
449  btagMuMon.pushTriggerType(TriggerJet);
450 
451  btagMuMon.pushL1TriggerType(TriggerL1CenJet);
452  btagMuMon.pushL1TriggerType(TriggerL1ForJet);
453  btagMuMon.pushL1TriggerType(TriggerL1TauJet);
454 
455 
456  objMonData<reco::CaloJetCollection> btagMon; // Generic btagMon
457 
458  // met Monitor
459  objMonData<reco::CaloMETCollection> metMon;
460  //metMon.setReco(metHandle);
461  metMon.setReco(fSelMetHandle);
462  metMon.setLimits(metEtaMax_, metMin_, metDRMatch_, metL1DRMatch_, dRMax_, thresholdFactor_);
463 
464  metMon.pushTriggerType(TriggerMET);
465 
466  metMon.pushL1TriggerType(TriggerL1ETM);
467 
468  // tet Monitor
469  objMonData<reco::CaloMETCollection> tetMon;
470  //tetMon.setReco(metHandle);
471  tetMon.setReco(fSelMetHandle);
472  //tetMon.setLimits(tetEtaMax_=999., tetEtMin_=10, tetDRMatch_=999);
473  tetMon.setLimits(999., 10., 999., 999., dRMax_, thresholdFactor_);
474 
475  tetMon.pushTriggerType(TriggerTET);
476 
477  tetMon.pushL1TriggerType(TriggerL1ETT);
478 
479  // default Monitor
480  //objMonData<trigger::TriggerEvent> defMon;
481  objMonData<reco::CaloMETCollection> defMon;
482  defMon.setLimits(999., 3., 999., 999., dRMax_, thresholdFactor_);
483 
484  // vector to hold monitors
485  // interface is through virtual class BaseMonitor
486  std::vector<BaseMonitor*> monitors;
487 
488  //monitors.push_back(&jetMon);
489 
490  monitors.push_back(&muoMon);
491  monitors.push_back(&eleMon);
492  monitors.push_back(&tauMon);
493  monitors.push_back(&phoMon);
494  monitors.push_back(&jetMon);
495  monitors.push_back(&btagMon);
496  monitors.push_back(&metMon);
497  monitors.push_back(&tetMon);
498  /*
499  */
500 
501  // int bx = iEvent.bunchCrossing();
502  /*
503  // Fill HLTPassed_Correlation Matrix bin (i,j) = (Any,Any)
504  // --------------------------------------------------------
505  int anyBinNumber = ME_HLTPassPass_->getTH2F()->GetXaxis()->FindBin("HLT_Any");
506  // any triger accepted
507  if(triggerResults->accept()){
508 
509  ME_HLTPassPass_->Fill(anyBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter
510 
511  }
512  */
513 
514  fillHltMatrix(triggerNames);
515 
516 
517  // Loop over paths
518  // --------------------
519  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
520 
521  LogTrace("FourVectorHLTOffline") << " unique path " << v->getPath() << endl;
522 
523  unsigned int pathByIndex = triggerNames.triggerIndex(v->getPath());
524 
525  // path must be in the menu
526  if(pathByIndex >= fTriggerResults->size() ) continue;
527 
528 
529  // Fill HLTPassed Matrix and HLTPassFail Matrix
530  // --------------------------------------------------------
531 
532 // if(triggerResults->accept(pathByIndex)){
533 
534 // int pathBinNumber = ME_HLT_BX->getTH2F()->GetYaxis()->FindBin(v->getPath().c_str());
535 // ME_HLT_BX->Fill(bx,pathBinNumber-1);
536 
537 // //if(hasHLTPassed(fCustomBXPath,triggerNames)) {
538 
539 // //ME_HLT_CUSTOM_BX->Fill(bx,pathBinNumber-1);
540 
541 // //}
542 
543 // } // end if accept
544 
545  // Fill histogram of filter ocupancy for each HLT path
546  // ---------------------------------
547  unsigned int lastModule = triggerResults->index(pathByIndex);
548 
549  //check if hlt passed
550  bool hltPathPassed = triggerResults->accept(pathByIndex);
551 
552  //go through the list of filters
553  for(unsigned int filt = 0; filt < v->filtersAndIndices.size(); filt++){
554 
555  int binNumber = v->getFiltersHisto()->getTH1()->GetXaxis()->FindBin(v->filtersAndIndices[filt].first.c_str());
556 
557  // if hlt path passed, then all the modules passed
558  // otherwise the module that issued the decision is the first fail
559  // this means that all modules before it passed
560  if(hltPathPassed) {
561 
562  v->getFiltersHisto()->Fill(binNumber-1);//binNumber1 = 0 = first filter
563  }
564  else if(v->filtersAndIndices[filt].second < lastModule){
565  v->getFiltersHisto()->Fill(binNumber-1);//binNumber1 = 0 = first filter
566  }
567 
568  } // end for filt
569 
570  } // end for diag paths
571 
572  // Main loop over paths
573  // --------------------
574  for(PathInfoCollection::iterator v = hltPaths_.begin(); v!= hltPaths_.end(); ++v ) {
575 
576  LogTrace("FourVectorHLTOffline") << " path " << v->getPath() << endl;
577 
578  if (v->getPath().find("BTagIP") != std::string::npos ) btagMon = btagIPMon;
579  else btagMon = btagMuMon;
580 
581  // set flag for muon monitor if L2-muon or L1-muon type path
582  if (v->getPath().find("L2Mu") != std::string::npos || v->getPath().find("L1Mu") != std::string::npos ) muoMon.setL2MuFlag(true);
583  else muoMon.setL2MuFlag(false);
584 
585  //if (v->getPath().find("HLT_Jet15U") == std::string::npos ) continue;
586  //if(*v != "HLT_L1Jet6U") continue;
587 
588  unsigned int pathByIndex = triggerNames.triggerIndex(v->getPath());
589 
590  if(pathByIndex >= fTriggerResults->size() ) continue;
591 
592  // did we pass the denomPath?
593  bool denompassed = false;
594 
595  for(int i = 0; i < npath; ++i) {
596 
597  if (triggerResults->accept(i) && triggerNames.triggerName(i).find(v->getDenomPath()) != std::string::npos && triggerNames.triggerName(i).find("HLT_Mult") == std::string::npos )
598  {
599  denompassed = true;
600  break;
601  }
602  }
603 
604  if (denompassed)
605  {
606 
607  //LogTrace("FourVectorHLTOffline") << " denominator path " << v->getPath() << endl;
608 
609 
610  // Get the righe monitor for this path
611  // -----------------------------------
612  BaseMonitor* mon = NULL;
613 
614  for(std::vector<BaseMonitor*>::iterator mit = monitors.begin(); mit!= monitors.end(); ++mit ) {
615 
616  if((*mit)->isTriggerType(v->getObjectType())) {
617 
618  mon = *mit;
619  break;
620 
621  }
622 
623  }
624 
625  // if cannot find moniotor for the path, go to next path
626  //if(!mon) continue;
627 
628  // if cannot find moniotor for the path, assign the default
629  if(!mon) mon = &defMon;
630 
631  // attach this path to mon
632  mon->setPath(v);
633 
634  // clear sets of matched objects
635  mon->clearSets();
636 
637  v->getObjectType();
638 
639  // monitor offline (RECO objects)
641  mon->monitorOffline();
642 
643  // monitor L1 (only if L1 passed and can find GTSeed)
645  bool l1accept = false;
646  edm::InputTag l1testTag(v->getl1Path(),"",processname_);
647  const int l1Index = fTriggerObj->filterIndex(l1testTag);
648 
649  if ( l1Index >= fTriggerObj->sizeFilters() ) {
650 
651  LogTrace("FourVectorHLTOffline") << "Cannot find L1GTSeed of the path " << v->getPath() << endl;
652  LogTrace("FourVectorHLTOffline") << "\t L1GTSeed name = " << v->getl1Path() << endl;
653  LogTrace("FourVectorHLTOffline") << "\t tried with tag " << l1testTag << endl;
654  LogTrace("FourVectorHLTOffline") <<"\t module index = "<< l1Index << endl;
655 
656  }
657 
658  // monitor L1 object
659  mon->monitorL1(l1Index, this);
660 
661  // fill matching b/w Offline and L1 objects
662  mon->fillL1Match(this);
663 
664  // monitor Online (only if HLT passed)
666  bool numpassed = false;
667 
668  // did we pass the numerator path, i.e. HLT path?
669  for(int i = 0; i < npath; ++i) {
670 
671  if ( triggerResults->accept(i) && triggerNames.triggerName(i) == v->getPath() ) numpassed = true;
672 
673  }
674 
675  if (!numpassed) continue;
676 
677  if (!l1accept) {
678 
679  LogDebug("FourVectorHLTOffline")
680  << "This should not happen. HLT passed, but L1 Seed not passed for hlt path "<< endl
681  << "HLT path: " << v->getPath() << "\t HLTLevel1GTSeed: " << v->getl1Path();
682 
683  }
684 
685  // fill scaler histograms
686  edm::InputTag filterTag = v->getTag();
687 
688  // loop through indices and see if the filter is
689  // on the list of filters used by this path
690  //----------------------------------------------
691  if (v->getLabel() == "dummy"){
692  const vector<string> filterLabels = hltConfig_.moduleLabels(v->getPath());
693 
694  //loop over labels
695  for (vector<string>::const_iterator labelIter= filterLabels.begin(); labelIter!=filterLabels.end(); labelIter++) {
696 
697  edm::InputTag testTag(*labelIter,"",processname_);
698 
699  int testindex = fTriggerObj->filterIndex(testTag);
700 
701  // last match wins...
702  if ( !(testindex >= fTriggerObj->sizeFilters()) ) {
703 
704  filterTag = testTag;
705  v->setLabel(*labelIter);}
706 
707  }
708 
709  } // end for
710 
711  const int hltIndex = fTriggerObj->filterIndex(filterTag);
712  if ( hltIndex >= fTriggerObj->sizeFilters() ) {
713 
714  LogTrace("FourVectorHLTOffline") << "WTF no index "<< hltIndex << " of that name " << filterTag << endl;
715  continue; // not in this event
716 
717  }
718 
719  mon->monitorOnline(hltIndex, l1Index, this);
720 
721  mon->fillOnlineMatch(l1Index, this);
722 
723  } //denompassed
724 
725 
726  } //pathinfo loop
727 
728 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
i
int i
Definition: DBlmapReader.cc:9
BaseMonitor::fillL1Match
virtual void fillL1Match(FourVectorHLTOffline *fv)=0
edm::Event::triggerNames
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:204
FourVectorHLTOffline::selectPhotons
void selectPhotons(const edm::Handle< reco::PhotonCollection > &phoHandle)
Definition: FourVectorHLTOffline.cc:2420
BaseMonitor::monitorOnline
virtual void monitorOnline(const int hltIndex, const int l1Index, FourVectorHLTOnline *fv)=0
FourVectorHLTOffline::fSelElectronsHandle
edm::Handle< reco::GsfElectronCollection > fSelElectronsHandle
Definition: FourVectorHLTOffline.h:200
FourVectorHLTOffline::fSelMetHandle
edm::Handle< reco::CaloMETCollection > fSelMetHandle
Definition: FourVectorHLTOffline.h:209
BaseMonitor::fillOnlineMatch
virtual void fillOnlineMatch(const int l1Index, FourVectorHLTOnline *fv)=0
FourVectorHLTOffline::hltPaths_
PathInfoCollection hltPaths_
Definition: FourVectorHLTOffline.h:720
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
trigger::TriggerL1Mu
enum start value shifted to 81 so as to avoid clashes with PDG codes
Definition: TriggerTypeDefs.h:31
FourVectorHLTOffline::fillHltMatrix
void fillHltMatrix(const edm::TriggerNames &triggerNames)
Definition: FourVectorHLTOffline.cc:1588
FourVectorHLTOffline::fSelMuonsHandle
edm::Handle< reco::MuonCollection > fSelMuonsHandle
Definition: FourVectorHLTOffline.h:197
NULL
#define NULL
Definition: scimark2.h:8
FourVectorHLTOffline::gsfElectronToken
edm::EDGetTokenT< reco::GsfElectronCollection > gsfElectronToken
Definition: FourVectorHLTOffline.h:335
FourVectorHLTOffline::triggerResultsToken
edm::EDGetTokenT< edm::TriggerResults > triggerResultsToken
Definition: FourVectorHLTOffline.h:329
FourVectorHLTOffline::fBeamSpotHandle
edm::Handle< reco::BeamSpot > fBeamSpotHandle
Definition: FourVectorHLTOffline.h:123
BaseMonitor::monitorOffline
virtual void monitorOffline(void)=0
FourVectorHLTOffline::fSelTausHandle
edm::Handle< reco::PFTauCollection > fSelTausHandle
Definition: FourVectorHLTOffline.h:214
objMonData::setRecoB
void setRecoB(edm::Handle< reco::JetTagCollection > offCollB)
Definition: FourVectorHLTOffline.h:767
FourVectorHLTOffline::hltPathsDiagonal_
PathInfoCollection hltPathsDiagonal_
Definition: FourVectorHLTOffline.h:722
FourVectorHLTOffline::triggerSummaryFUToken
edm::EDGetTokenT< trigger::TriggerEvent > triggerSummaryFUToken
Definition: FourVectorHLTOffline.h:332
FourVectorHLTOffline::pixelTrackToken
edm::EDGetTokenT< reco::TrackCollection > pixelTrackToken
Definition: FourVectorHLTOffline.h:342
FourVectorHLTOffline::photonToken
edm::EDGetTokenT< reco::PhotonCollection > photonToken
Definition: FourVectorHLTOffline.h:341
objMonData::setLimits
void setLimits(float etaMax, float etMin, float drMatch)
Definition: FourVectorHLTOnline.h:607
FourVectorHLTOffline::fTriggerResults
edm::Handle< edm::TriggerResults > fTriggerResults
Definition: FourVectorHLTOffline.h:122
FourVectorHLTOffline::tauProdToken
edm::EDGetTokenT< std::vector< reco::PFTau > > tauProdToken
Definition: FourVectorHLTOffline.h:336
FourVectorHLTOffline::beamSpotToken
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken
Definition: FourVectorHLTOffline.h:333
FourVectorHLTOffline::selectJets
void selectJets(const edm::Event &iEvent, const edm::Handle< reco::CaloJetCollection > &jetHandle)
Definition: FourVectorHLTOffline.cc:2452
FourVectorHLTOffline::triggerSummaryToken
edm::EDGetTokenT< trigger::TriggerEvent > triggerSummaryToken
Definition: FourVectorHLTOffline.h:331
FourVectorHLTOffline::hltConfig_
HLTConfigProvider hltConfig_
Definition: FourVectorHLTOffline.h:355
FourVectorHLTOffline::iC5calojetToken
edm::EDGetTokenT< reco::CaloJetCollection > iC5calojetToken
Definition: FourVectorHLTOffline.h:337
triggerResults
static std::string const triggerResults
Definition: EdmProvDump.cc:41
FourVectorHLTOffline::selectTaus
void selectTaus(const edm::Event &iEvent)
Definition: FourVectorHLTOffline.cc:2505
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
FourVectorHLTOffline::selectElectrons
void selectElectrons(const edm::Event &iEvent, const edm::EventSetup &iSetup, const edm::Handle< reco::GsfElectronCollection > &eleHandle)
Definition: FourVectorHLTOffline.cc:2333
FourVectorHLTOffline::muonRecoCollectionToken
edm::EDGetTokenT< reco::MuonCollection > muonRecoCollectionToken
Definition: FourVectorHLTOffline.h:334
HLTConfigProvider::moduleLabels
const std::vector< std::string > & moduleLabels(unsigned int trigger) const
label(s) of module(s) on a trigger path
Definition: HLTConfigProvider.h:113
BaseMonitor::clearSets
virtual void clearSets(void)=0
FourVectorHLTOffline::METToken
edm::EDGetTokenT< reco::CaloMETCollection > METToken
Definition: FourVectorHLTOffline.h:340
FourVectorHLTOffline::fSelJetsHandle
edm::Handle< reco::CaloJetCollection > fSelJetsHandle
Definition: FourVectorHLTOffline.h:206
BaseMonitor::setPath
virtual void setPath(FourVectorHLTOnline::PathInfoCollection::iterator v)=0
FourVectorHLTOffline::jlipBtagToken
edm::EDGetTokenT< reco::JetTagCollection > jlipBtagToken
Definition: FourVectorHLTOffline.h:338
LaserDQM_cfi.mon
tuple mon
Definition: LaserDQM_cfi.py:3
FourVectorHLTOffline::selectMet
void selectMet(const edm::Handle< reco::CaloMETCollection > &metHandle)
Definition: FourVectorHLTOffline.cc:2482
FourVectorHLTOffline::softMuBtagToken
edm::EDGetTokenT< reco::JetTagCollection > softMuBtagToken
Definition: FourVectorHLTOffline.h:339
BaseMonitor::monitorL1
virtual void monitorL1(const int l1Index, FourVectorHLTOnline *fv)=0
FourVectorHLTOffline::triggerResultsFUToken
edm::EDGetTokenT< edm::TriggerResults > triggerResultsFUToken
Definition: FourVectorHLTOffline.h:330
FourVectorHLTOffline::fTriggerObj
edm::Handle< trigger::TriggerEvent > fTriggerObj
Definition: FourVectorHLTOffline.h:121
objMonData::setReco
void setReco(edm::Handle< T > offColl)
Definition: FourVectorHLTOnline.h:618
FourVectorHLTOffline::selectMuons
void selectMuons(const edm::Handle< reco::MuonCollection > &muonHandle)
Definition: FourVectorHLTOffline.cc:2308
gsfElectrons_cfi.gsfElectrons
tuple gsfElectrons
Definition: gsfElectrons_cfi.py:171
void FourVectorHLTOffline::beginJob ( void  )
privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 734 of file FourVectorHLTOffline.cc.

References dirname_, nev_, cppFunctionSkipper::operator, DQMStore::rmdir(), and DQMStore::setCurrentFolder().

735 {
736  nev_ = 0;
737  DQMStore *dbe = 0;
738  dbe = Service<DQMStore>().operator->();
739 
740  if (dbe) {
741  dbe->setCurrentFolder(dirname_);
742  dbe->rmdir(dirname_);
743  }
744 
745 
746  if (dbe) {
747  dbe->setCurrentFolder(dirname_);
748  }
749 }
void FourVectorHLTOffline::beginLuminosityBlock ( const edm::LuminosityBlock &  lumiSeg,
const edm::EventSetup &  c 
)
privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1775 of file FourVectorHLTOffline.cc.

1775  {
1776 
1777  //int lumi = int(lumiSeg.id().luminosityBlock());
1778  //if(lumi < 74 || lumi > 77) fLumiFlag = false;
1779  //else fLumiFlag = true;
1780 
1781 }
void FourVectorHLTOffline::beginRun ( const edm::Run &  run,
const edm::EventSetup &  c 
)
privatevirtual

add dataset name and thier triggers to the list

Reimplemented from edm::EDAnalyzer.

Definition at line 761 of file FourVectorHLTOffline.cc.

References bjetEtaMax_, DQMStore::book1D(), DQMStore::book2D(), custompathnamepairs_, HLTConfigProvider::datasetContent(), makeLayoutFileForGui::datasetNames, HLTConfigProvider::datasetNames(), dbe_, dirname_, doCombineRuns_, dRMax_, electronEtaMax_, fGroupL1TempCountPair, fGroupName, fGroupNamePathsPair, fGroupTempCountPair, filters, first, fIsSetup, fPathBxTempCountPair, fPathTempCountPair, g, getHltThresholdFromName(), getL1ConditionModuleName(), getTriggerTypeParsePathName(), hltConfig_, hltPaths_, hltPathsDiagonal_, i, edm::RunBase::id(), HLTConfigProvider::init(), j, jetEtaMax_, gen::k, LogDebug, LogTrace, metEtaMax_, HLTConfigProvider::moduleEDMType(), HLTConfigProvider::moduleIndex(), HLTConfigProvider::moduleLabels(), edm::moduleName(), HLTConfigProvider::moduleType(), muonEtaMax_, n, nBins2D_, nBins_, nBinsOneOverEt_, cppFunctionSkipper::operator, timingPdfMaker::pathname, EgammaValidation_cff::pathName, pathsSummaryFilterCountsFolder_, pathsSummaryFolder_, photonEtaMax_, Pi, plotAll_, processname_, PtMinSelector_cfg::ptMin, removeVersions(), edm::second(), MonitorElement::setAxisTitle(), MonitorElement::setBinLabel(), DQMStore::setCurrentFolder(), setupHltMatrix(), HLTConfigProvider::size(), AlCaHLTBitMon_QueryRunRegistry::string, tauEtaMax_, indexGen::title, trackEtaMax_, trigger::TriggerBJet, trigger::TriggerElectron, trigger::TriggerJet, trigger::TriggerL1CenJet, trigger::TriggerL1ETM, trigger::TriggerL1ForJet, trigger::TriggerL1IsoEG, trigger::TriggerL1Mu, trigger::TriggerL1NoIsoEG, trigger::TriggerL1TauJet, trigger::TriggerMET, trigger::TriggerMuon, HLTConfigProvider::triggerName(), trigger::TriggerPhoton, trigger::TriggerTau, trigger::TriggerTET, trigger::TriggerTrack, useUM, and findQualityFiles::v.

762 {
763 
764  LogDebug("FourVectorHLTOffline") << "beginRun, run " << run.id();
765 
766  if(fIsSetup) return;
767 
768  // HLT config does not change within runs!
769  bool changed=false;
770 
771  if (!hltConfig_.init(run, c, processname_, changed)) {
772 
773  processname_ = "FU";
774 
775  if (!hltConfig_.init(run, c, processname_, changed)){
776 
777  LogDebug("FourVectorHLTOffline") << "HLTConfigProvider failed to initialize.";
778 
779  }
780 
781  // check if trigger name in (new) config
782  // cout << "Available TriggerNames are: " << endl;
783  // hltConfig_.dump("Triggers");
784  }
785 
786  if (1) {
787 
788  DQMStore *dbe = 0;
789  dbe = Service<DQMStore>().operator->();
790 
791  if (dbe) {
792  dbe->setCurrentFolder(dirname_);
793  }
794 
795  const unsigned int n(hltConfig_.size());
796 
797  if (plotAll_){
798 
799  for (unsigned int j=0; j!=n; ++j) {
800 
801  std::string pathname = hltConfig_.triggerName(j);
802 
803  string l1pathname = getL1ConditionModuleName(pathname);
804 
805  int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
806 
807  int objectType = getTriggerTypeParsePathName(pathname);
808 
809  for (unsigned int i=0; i!=n; ++i) {
810 
811  std::string denompathname = hltConfig_.triggerName(i);
812  int denomobjectType = getTriggerTypeParsePathName(denompathname);
813 
814 
815 
816  std::string filtername("dummy");
817  float ptMin = 0.0;
818  float ptMax = 100.0;
819  if (plotAll_ && denomobjectType == objectType && objectType != 0) {
820 
821  int hltThreshold = getHltThresholdFromName(pathname);
822  int l1Threshold = getHltThresholdFromName(l1pathname);
823  hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
824 
825  }
826 
827  }
828  }
829 
830  } // end if plotAll
831  else {
832 
833  // plot all diagonal combinations plus any other specified pairs
834  for (unsigned int i=0; i!=n; ++i) {
835 
836  std::string denompathname = "";
837  std::string pathname = hltConfig_.triggerName(i);
838  //parse pathname to guess object type
839  int objectType = getTriggerTypeParsePathName(pathname);
840 
841  string l1pathname = getL1ConditionModuleName(pathname);
842  int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
843 
844  std::string filtername("dummy");
845  float ptMin = 0.0;
846  float ptMax = 100.0;
847 
848  if (objectType == trigger::TriggerPhoton) ptMax = 400.0;
849  if (objectType == trigger::TriggerElectron) ptMax = 300.0;
850  if (objectType == trigger::TriggerMuon) ptMax = 300.0;
851  if (objectType == trigger::TriggerTau) ptMax = 300.0;
852  if (objectType == trigger::TriggerJet) ptMax = 700.0;
853  if (objectType == trigger::TriggerBJet) ptMax = 300.0;
854  if (objectType == trigger::TriggerMET) ptMax = 500.0;
855  if (objectType == trigger::TriggerTET) ptMax = 1000.0;
856  if (objectType == trigger::TriggerTrack) ptMax = 100.0;
857 
858  // keep track of all paths, except for FinalPath
859  if (objectType != -1 && pathname.find("FinalPath") == std::string::npos){
860 
861  int hltThreshold = getHltThresholdFromName(pathname);
862  int l1Threshold = getHltThresholdFromName(l1pathname);
863 
864  hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
865 
866  hltPathsDiagonal_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
867 
868  }
869 
870  } // end for i
871 
872  // now loop over denom/num path pairs specified in cfg,
873  // recording the off-diagonal ones
874  for (std::vector<std::pair<std::string, std::string> >::iterator custompathnamepair = custompathnamepairs_.begin(); custompathnamepair != custompathnamepairs_.end(); ++custompathnamepair) {
875 
876  std::string numpathname = custompathnamepair->first;
877  std::string denompathname = custompathnamepair->second;
878 
879  if (numpathname != denompathname) {
880 
881  // check that denominator exists
882  bool founddenominator = false;
883  for (unsigned int k=0; k!=n; ++k) {
884 
885  string n_pathname = hltConfig_.triggerName(k);
886 
887  if (n_pathname.find(denompathname) != std::string::npos) {
888 
889  LogDebug("FourVectorHLTOffline") << "denompathname is selected to be = " << n_pathname << endl;;
890  founddenominator = true;
891 
892  break;
893 
894  }
895  }
896 
897  if (!founddenominator) {
898 
899  edm::LogInfo("FourVectorHLTOffline") << "denompathname not found, go to the next pair numearator-denominator" << endl;
900 
901  // go to the next pair
902  continue;
903 
904  }
905 
906  // check that numerator exists
907  for (unsigned int j=0; j!=n; ++j) {
908  bool foundnumerator = false;
909 
910  string pathname = hltConfig_.triggerName(j);
911 
912  LogDebug("FourVectorHLTOffline") << "check if path " << pathname << " is numpathname = " << numpathname << endl;
913  if (hltConfig_.triggerName(j).find(numpathname)!= std::string::npos) {
914 
915  LogDebug("FourVectorHLTOffline") << "pathname is selected to be = " << denompathname << endl;;
916  foundnumerator = true;
917 
918  }
919 
920 
921  if (!foundnumerator) {
922 
923  edm::LogInfo("FourVectorHLTOffline") << "pathname not found, ignoring " << pathname;
924  continue;
925 
926  }
927 
928  string l1pathname = getL1ConditionModuleName(pathname);
929  int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
930  int objectType = getTriggerTypeParsePathName(pathname);
931 
932  std::string filtername("dummy");
933  float ptMin = 0.0;
934  float ptMax = 100.0;
935 
936  if (objectType == trigger::TriggerPhoton) ptMax = 400.0;
937  if (objectType == trigger::TriggerElectron) ptMax = 300.0;
938  if (objectType == trigger::TriggerMuon) ptMax = 300.0;
939  if (objectType == trigger::TriggerTau) ptMax = 300.0;
940  if (objectType == trigger::TriggerJet) ptMax = 700.0;
941  if (objectType == trigger::TriggerBJet) ptMax = 300.0;
942  if (objectType == trigger::TriggerMET) ptMax = 500.0;
943  if (objectType == trigger::TriggerTET) ptMax = 1000.0;
944  if (objectType == trigger::TriggerTrack) ptMax = 100.0;
945 
946  // monitor regardless of the objectType of the path
947  if (objectType != 0) {
948  int hltThreshold = getHltThresholdFromName(pathname);
949  int l1Threshold = getHltThresholdFromName(l1pathname);
950  hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
951 
952  }
953 
954  } // end for j, loop over paths
955 
956  } // end if not same num and denominator
957 
958  } // end for pair
959 
960  } // end else
961 
962 
963  vector<string> allPaths;
964  // fill vectors of Muon, Egamma, JetMet, Rest, and Special paths
965 
966  int vi = 0;
967 
968  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
969 
970  std::string pathName = removeVersions(v->getPath());
971  //int objectType = v->getObjectType();
972 
973  vector<int> tempCount(5,0);
974 
975  fPathTempCountPair.push_back(make_pair(pathName,0));
976  fPathBxTempCountPair.push_back(make_pair(pathName,tempCount));
977 
978  allPaths.push_back(pathName);
979 
980  }
981 
982  fPathTempCountPair.push_back(make_pair("HLT_Any",0));
983 
984  fGroupName.push_back("All");
985 
986  for(unsigned int g=0; g<fGroupName.size(); g++) {
987 
988  //fGroupTempCountPair.push_back(make_pair(fGroupName[g],0));
989  //fGroupL1TempCountPair.push_back(make_pair(fGroupName[g],0));
990 
991  }
992 
993  dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());
994 
995  fGroupNamePathsPair.push_back(make_pair("All",allPaths));
996 
998  vector<string> datasetNames = hltConfig_.datasetNames() ;
999  for (unsigned int i=0;i<datasetNames.size();i++) {
1000 
1001  vector<string> datasetPaths = hltConfig_.datasetContent(datasetNames[i]);
1002  fGroupNamePathsPair.push_back(make_pair(datasetNames[i],datasetPaths));
1003 
1004  }
1005 
1006 
1007  for (unsigned int g=0;g<fGroupNamePathsPair.size();g++) {
1008 
1009  fGroupTempCountPair.push_back(make_pair(fGroupNamePathsPair[g].first,0));
1010  fGroupL1TempCountPair.push_back(make_pair(fGroupNamePathsPair[g].first,0));
1011  setupHltMatrix(fGroupNamePathsPair[g].first,fGroupNamePathsPair[g].second);
1012 
1013  }
1014 
1015  // setupHltLsPlots();
1016  // setupHltBxPlots();
1017 
1018  vi = 0;
1019 
1020  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
1021  vi++;
1022 
1023  // -------------------------
1024  //
1025  // Filters for each path
1026  //
1027  // -------------------------
1028 
1029  // get all modules in this HLT path
1030  std::string pathName = removeVersions(v->getPath());
1031  vector<string> moduleNames = hltConfig_.moduleLabels(v->getPath());
1032 
1033  int numModule = 0;
1034  string moduleName, moduleType, moduleEDMType;
1035  unsigned int moduleIndex;
1036 
1037  //print module name
1038  vector<string>::const_iterator iDumpModName;
1039  for (iDumpModName = moduleNames.begin();iDumpModName != moduleNames.end();iDumpModName++) {
1040 
1041  moduleName = *iDumpModName;
1042  moduleType = hltConfig_.moduleType(moduleName);
1043  moduleEDMType = hltConfig_.moduleEDMType(moduleName);
1044  moduleIndex = hltConfig_.moduleIndex(v->getPath(), moduleName);
1045 
1046  LogTrace ("FourVectorHLTOffline") << "Module " << numModule
1047  << " is called " << moduleName
1048  << " , type = " << moduleType
1049  << " , EDMtype = " << moduleEDMType
1050  << " , index = " << moduleIndex
1051  << endl;
1052 
1053  numModule++;
1054 
1055  if((moduleType.find("Filter") != string::npos && moduleType.find("HLTTriggerTypeFilter") == string::npos ) ||
1056  (moduleType.find("Associator") != string::npos) ||
1057  (moduleType.find("HLTLevel1GTSeed") != string::npos) ||
1058  (moduleType.find("HLTGlobalSumsCaloMET") != string::npos) ||
1059  (moduleType.find("HLTPrescaler") != string::npos) ||
1060  (moduleEDMType.find("EDFilter") != string::npos) ) {
1061 
1062  //std::pair<std::string, int> filterIndexPair;
1063  //filterIndexPair.first = moduleName;
1064  //filterIndexPair.second = moduleIndex;
1065  //v->filtersAndIndices.push_back(filterIndexPair);
1066  v->filtersAndIndices.push_back(make_pair(moduleName,moduleIndex));
1067 
1068  }
1069 
1070 
1071  }//end for modulesName
1072 
1073  dbe_->setCurrentFolder(pathsSummaryFilterCountsFolder_.c_str());
1074 
1075  //int nbin_sub = 5;
1076  int nbin_sub = v->filtersAndIndices.size()+2;
1077 
1078 
1079  //TString thisPath = v->getPath();
1080 
1081  // count plots for subfilter
1082  MonitorElement* filters = dbe_->book1D("Filters_" + pathName,
1083  "Filters_" + pathName,
1084  nbin_sub+1, -0.5, 0.5+(double)nbin_sub);
1085 
1086  for(unsigned int filt = 0; filt < v->filtersAndIndices.size(); filt++){
1087 
1088  if (filters)
1089  filters->setBinLabel(filt+1, (v->filtersAndIndices[filt]).first);
1090 
1091  }
1092 
1093  // bjk here
1094 // // book Count vs LS
1095 // dbe_->setCurrentFolder(pathsIndividualHLTPathsPerLSFolder_.c_str());
1096 // MonitorElement* tempME = dbe_->book1D(v->getPath() + "_count_per_LS",
1097 // pathName + " count per LS",
1098 // nLS_, 0,nLS_);
1099 // tempME->setAxisTitle("Luminosity Section");
1100 
1101  v->setFilterHistos(filters);
1102 
1103  } // end for paths
1104 
1105  // now set up all of the histos for each path-denom
1106  for(PathInfoCollection::iterator v = hltPaths_.begin(); v!= hltPaths_.end(); ++v ) {
1107 
1108  MonitorElement *NOn=0;
1109  MonitorElement *onEtOn=0;
1110  MonitorElement *onOneOverEtOn=0;
1111  MonitorElement *onEtavsonPhiOn=0;
1112  MonitorElement *NOff=0;
1113  MonitorElement *offEtOff=0;
1114  MonitorElement *offEtavsoffPhiOff=0;
1115  MonitorElement *NL1=0;
1116  MonitorElement *l1EtL1=0;
1117  MonitorElement *l1Etavsl1PhiL1=0;
1118  MonitorElement *NL1On=0;
1119  MonitorElement *l1EtL1On=0;
1120  MonitorElement *l1Etavsl1PhiL1On=0;
1121  MonitorElement *NL1Off=0;
1122  MonitorElement *offEtL1Off=0;
1123  MonitorElement *offEtavsoffPhiL1Off=0;
1124  MonitorElement *NOnOff=0;
1125  MonitorElement *offEtOnOff=0;
1126  MonitorElement *offEtavsoffPhiOnOff=0;
1127  MonitorElement *NL1OnUM=0;
1128  MonitorElement *l1EtL1OnUM=0;
1129  MonitorElement *l1Etavsl1PhiL1OnUM=0;
1130  MonitorElement *NL1OffUM=0;
1131  MonitorElement *offEtL1OffUM=0;
1132  MonitorElement *offEtavsoffPhiL1OffUM=0;
1133  MonitorElement *NOnOffUM=0;
1134  MonitorElement *offEtOnOffUM=0;
1135  MonitorElement *offEtavsoffPhiOnOffUM=0;
1136  MonitorElement *offDRL1Off=0;
1137  MonitorElement *offDROnOff=0;
1138  MonitorElement *l1DRL1On=0;
1139 
1140  std::string pathName = removeVersions(v->getPath());
1141  std::string labelname("dummy");
1142  labelname = pathName + "_wrt_" + v->getDenomPath();
1143 
1144  std::string histoname(labelname+"_NOn");
1145  std::string title(labelname+" N online");
1146  double histEtaMax = 2.5;
1147 
1148  if (v->getObjectType() == trigger::TriggerMuon || v->getObjectType() == trigger::TriggerL1Mu) {
1149 
1150  histEtaMax = muonEtaMax_;
1151 
1152  }
1153  else if (v->getObjectType() == trigger::TriggerElectron || v->getObjectType() == trigger::TriggerL1NoIsoEG || v->getObjectType() == trigger::TriggerL1IsoEG )
1154  {
1155  histEtaMax = electronEtaMax_;
1156  }
1157  else if (v->getObjectType() == trigger::TriggerTau || v->getObjectType() == trigger::TriggerL1TauJet )
1158  {
1159  histEtaMax = tauEtaMax_;
1160  }
1161  else if (v->getObjectType() == trigger::TriggerJet || v->getObjectType() == trigger::TriggerL1CenJet || v->getObjectType() == trigger::TriggerL1ForJet )
1162  {
1163  histEtaMax = jetEtaMax_;
1164  }
1165  else if (v->getObjectType() == trigger::TriggerBJet)
1166  {
1167  histEtaMax = bjetEtaMax_;
1168  }
1169  else if (v->getObjectType() == trigger::TriggerMET || v->getObjectType() == trigger::TriggerL1ETM )
1170  {
1171  histEtaMax = metEtaMax_;
1172  }
1173  else if (v->getObjectType() == trigger::TriggerPhoton)
1174  {
1175  histEtaMax = photonEtaMax_;
1176  }
1177  else if (v->getObjectType() == trigger::TriggerTrack)
1178  {
1179  histEtaMax = trackEtaMax_;
1180  }
1181 
1182  TString pathfolder = dirname_ + TString("/") + pathName;
1183  dbe_->setCurrentFolder(pathfolder.Data());
1184 
1185  NOn = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1186 
1187 
1188  histoname = labelname+"_NOff";
1189  title = labelname+" N Off";
1190  NOff = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1191 
1192  histoname = labelname+"_NL1";
1193  title = labelname+" N L1";
1194  NL1 = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1195 
1196  histoname = labelname+"_NL1On";
1197  title = labelname+" N L1On";
1198  NL1On = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1199 
1200  histoname = labelname+"_NL1Off";
1201  title = labelname+" N L1Off";
1202  NL1Off = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1203 
1204  histoname = labelname+"_NOnOff";
1205  title = labelname+" N OnOff";
1206  NOnOff = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1207 
1208  histoname = labelname+"_onEtOn";
1209  title = labelname+" onE_t online";
1210  onEtOn = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1211 
1212  histoname = labelname+"_onOneOverEtOn";
1213  title = labelname+" 1 / onE_t online";
1214  onOneOverEtOn = dbe->book1D(histoname.c_str(), title.c_str(),nBinsOneOverEt_, 0, 0.1);
1215  onOneOverEtOn->setAxisTitle("HLT 1/Et [1/GeV]");
1216 
1217  histoname = labelname+"_offEtOff";
1218  title = labelname+" offE_t offline";
1219  offEtOff = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1220 
1221  histoname = labelname+"_l1EtL1";
1222  title = labelname+" l1E_t L1";
1223  l1EtL1 = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1224 
1225  histoname = labelname+"_onEtaonPhiOn";
1226  title = labelname+" on#eta vs on#phi online";
1227  onEtavsonPhiOn = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1228 
1229  histoname = labelname+"_offEtaoffPhiOff";
1230  title = labelname+" off#eta vs off#phi offline";
1231  offEtavsoffPhiOff = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1232 
1233  histoname = labelname+"_l1Etal1PhiL1";
1234  title = labelname+" l1#eta vs l1#phi L1";
1235  l1Etavsl1PhiL1 = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1236 
1237  histoname = labelname+"_l1EtL1On";
1238  title = labelname+" l1E_t L1+online";
1239  l1EtL1On = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1240 
1241  histoname = labelname+"_offEtL1Off";
1242  title = labelname+" offE_t L1+offline";
1243  offEtL1Off = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1244 
1245  histoname = labelname+"_offEtOnOff";
1246  title = labelname+" offE_t online+offline";
1247  offEtOnOff = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1248 
1249  histoname = labelname+"_l1Etal1PhiL1On";
1250  title = labelname+" l1#eta vs l1#phi L1+online";
1251  l1Etavsl1PhiL1On = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1252 
1253  histoname = labelname+"_offEtaoffPhiL1Off";
1254  title = labelname+" off#eta vs off#phi L1+offline";
1255  offEtavsoffPhiL1Off = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1256 
1257  histoname = labelname+"_offEtaoffPhiOnOff";
1258  title = labelname+" off#eta vs off#phi online+offline";
1259  offEtavsoffPhiOnOff = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1260 
1261  if (useUM) {
1262 
1263  histoname = labelname+"_NL1OnUM";
1264  title = labelname+" N L1OnUM";
1265  NL1OnUM = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1266 
1267  histoname = labelname+"_NL1OffUM";
1268  title = labelname+" N L1OffUM";
1269  NL1OffUM = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1270 
1271  histoname = labelname+"_NOnOffUM";
1272  title = labelname+" N OnOffUM";
1273  NOnOffUM = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1274 
1275  histoname = labelname+"_l1EtL1OnUM";
1276  title = labelname+" l1E_t L1+onlineUM";
1277  l1EtL1OnUM = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1278 
1279  histoname = labelname+"_offEtL1OffUM";
1280  title = labelname+" offE_t L1+offlineUM";
1281  offEtL1OffUM = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1282 
1283  histoname = labelname+"_offEtOnOffUM";
1284  title = labelname+" offE_t online+offlineUM";
1285  offEtOnOffUM = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1286 
1287  histoname = labelname+"_l1Etal1PhiL1OnUM";
1288  title = labelname+" l1#eta vs l1#phi L1+onlineUM";
1289  l1Etavsl1PhiL1OnUM = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1290 
1291  histoname = labelname+"_offEtaoffPhiL1OffUM";
1292  title = labelname+" off#eta vs off#phi L1+offlineUM";
1293  offEtavsoffPhiL1OffUM = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1294 
1295  histoname = labelname+"_offEtaoffPhiOnOffUM";
1296  title = labelname+" off#eta vs off#phi online+offlineUM";
1297  offEtavsoffPhiOnOffUM = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1298 
1299  }
1300 
1301  histoname = labelname+"_l1DRL1On";
1302  title = labelname+" l1DR L1+online";
1303  l1DRL1On = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_);
1304 
1305  histoname = labelname+"_offDRL1Off";
1306  title = labelname+" offDR L1+offline";
1307  offDRL1Off = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_);
1308 
1309  histoname = labelname+"_offDROnOff";
1310  title = labelname+" offDR online+offline";
1311  offDROnOff = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_);
1312 
1313 
1314  v->setHistos( NOn, onEtOn, onOneOverEtOn, onEtavsonPhiOn, NOff, offEtOff, offEtavsoffPhiOff, NL1, l1EtL1, l1Etavsl1PhiL1, NL1On, l1EtL1On, l1Etavsl1PhiL1On, NL1Off, offEtL1Off, offEtavsoffPhiL1Off, NOnOff, offEtOnOff, offEtavsoffPhiOnOff, NL1OnUM, l1EtL1OnUM, l1Etavsl1PhiL1OnUM, NL1OffUM, offEtL1OffUM, offEtavsoffPhiL1OffUM, NOnOffUM, offEtOnOffUM, offEtavsoffPhiOnOffUM, offDRL1Off, offDROnOff, l1DRL1On
1315 );
1316 
1317  } // end for hltPath
1318 
1319  // bjk here
1320 // // HLT_Any
1321 // // book Count vs LS
1322 // dbe_->setCurrentFolder(pathsIndividualHLTPathsPerLSFolder_.c_str());
1323 // MonitorElement* tempME = dbe_->book1D("HLT_Any_count_per_LS",
1324 // "HLT_Any count per LS",
1325 // nLS_, 0,nLS_);
1326 // tempME->setAxisTitle("Luminosity Section");
1327 
1328  } // end if(1) dummy
1329 
1330  if(!doCombineRuns_) fIsSetup = true;
1331 
1332  return;
1333 
1334 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
HLTConfigProvider::size
unsigned int size() const
number of trigger paths in trigger table
Definition: HLTConfigProvider.h:88
FourVectorHLTOffline::setupHltMatrix
void setupHltMatrix(const std::string &label, std::vector< std::string > &paths)
Definition: FourVectorHLTOffline.cc:1491
Pi
const double Pi
Definition: CosmicMuonParameters.h:18
i
int i
Definition: DBlmapReader.cc:9
edm::RunBase::id
RunID const & id() const
Definition: RunBase.h:41
HLTConfigProvider::moduleType
const std::string moduleType(const std::string &module) const
C++ class name of module.
Definition: HLTConfigProvider.h:141
HLTConfigProvider::triggerName
const std::string & triggerName(unsigned int triggerIndex) const
Definition: HLTConfigProvider.h:103
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:928
FourVectorHLTOffline::hltPaths_
PathInfoCollection hltPaths_
Definition: FourVectorHLTOffline.h:720
trigger::TriggerL1Mu
enum start value shifted to 81 so as to avoid clashes with PDG codes
Definition: TriggerTypeDefs.h:31
FourVectorHLTOffline::getTriggerTypeParsePathName
int getTriggerTypeParsePathName(const std::string &pathname)
Definition: FourVectorHLTOffline.cc:2210
FourVectorHLTOffline::fPathBxTempCountPair
std::vector< std::pair< std::string, std::vector< int > > > fPathBxTempCountPair
Definition: FourVectorHLTOffline.h:317
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:901
HLTConfigProvider::moduleEDMType
const std::string moduleEDMType(const std::string &module) const
C++ base class name of module.
Definition: HLTConfigProvider.h:146
filters
std::vector< TPRegexp > filters
Definition: eve_filter.cc:25
g
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g
Definition: Activities.doc:4
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
FourVectorHLTOffline::hltPathsDiagonal_
PathInfoCollection hltPathsDiagonal_
Definition: FourVectorHLTOffline.h:722
FourVectorHLTOffline::custompathnamepairs_
std::vector< std::pair< std::string, std::string > > custompathnamepairs_
Definition: FourVectorHLTOffline.h:312
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
FourVectorHLTOffline::getL1ConditionModuleName
const std::string getL1ConditionModuleName(const std::string &pathname)
Definition: FourVectorHLTOffline.cc:2241
edm::moduleName
std::string moduleName(Provenance const &provenance)
Definition: Provenance.cc:27
EgammaValidation_cff.pathName
tuple pathName
Definition: EgammaValidation_cff.py:269
HLTConfigProvider::moduleIndex
unsigned int moduleIndex(unsigned int trigger, const std::string &module) const
slot position of module on trigger path (0 to size-1)
Definition: HLTConfigProvider.h:133
FourVectorHLTOffline::fPathTempCountPair
std::vector< std::pair< std::string, float > > fPathTempCountPair
Definition: FourVectorHLTOffline.h:316
j
int j
Definition: DBlmapReader.cc:9
FourVectorHLTOffline::hltConfig_
HLTConfigProvider hltConfig_
Definition: FourVectorHLTOffline.h:355
first
bool first
Definition: L1TdeRCT.cc:75
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
PtMinSelector_cfg.ptMin
tuple ptMin
Definition: PtMinSelector_cfg.py:44
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:79
HLTConfigProvider::moduleLabels
const std::vector< std::string > & moduleLabels(unsigned int trigger) const
label(s) of module(s) on a trigger path
Definition: HLTConfigProvider.h:113
HLTConfigProvider::datasetContent
const std::vector< std::string > & datasetContent(unsigned int dataset) const
names of trigger paths in dataset with index i
Definition: HLTConfigProvider.h:225
HLTConfigProvider::init
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
d&#39;tor
Definition: HLTConfigProvider.cc:65
FourVectorHLTOffline::fGroupTempCountPair
std::vector< std::pair< std::string, float > > fGroupTempCountPair
Definition: FourVectorHLTOffline.h:318
FourVectorHLTOffline::fGroupNamePathsPair
std::vector< std::pair< std::string, std::vector< std::string > > > fGroupNamePathsPair
Definition: FourVectorHLTOffline.h:320
FourVectorHLTOffline::removeVersions
std::string removeVersions(std::string histVersion)
Definition: FourVectorHLTOffline.cc:2625
FourVectorHLTOffline::pathsSummaryFilterCountsFolder_
std::string pathsSummaryFilterCountsFolder_
Definition: FourVectorHLTOffline.h:188
FourVectorHLTOffline::fGroupName
std::vector< std::string > fGroupName
Definition: FourVectorHLTOffline.h:194
FourVectorHLTOffline::fGroupL1TempCountPair
std::vector< std::pair< std::string, float > > fGroupL1TempCountPair
Definition: FourVectorHLTOffline.h:319
FourVectorHLTOffline::getHltThresholdFromName
int getHltThresholdFromName(const std::string &pathname)
Definition: FourVectorHLTOffline.cc:2550
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:928
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:639
HLTConfigProvider::datasetNames
const std::vector< std::string > & datasetNames() const
Definition: HLTConfigProvider.h:209
void FourVectorHLTOffline::cleanDRMatchSet ( mmset &  tempSet)

Clean DR Match Set.

Definition at line 1345 of file FourVectorHLTOffline.cc.

References i, and LogDebug.

Referenced by objMonData< T >::fillL1OffMatch(), objMonData< T >::fillOnL1Match(), and objMonData< T >::fillOnOffMatch().

1346 {
1347 
1348  LogDebug("FourVectorHLTOffline") << "cleanDRMatchSet(mmset& tempSet) " << "size of the set (before CLEANING) = " << tempSet.size() << " maps." << endl;
1349 
1350  if(tempSet.size() < 2) return;
1351 
1352  if(tempSet.size() > 10) {
1353 
1354  LogDebug("FourVectorHLTOffline") << "size of the set is too large. It will be truncated to 10." << endl;
1355  mmset::iterator it = tempSet.begin();
1356  for (int i=0;i<10;i++) { it++; }
1357  tempSet.erase( it, tempSet.end());
1358  LogDebug("FourVectorHLTOffline") << "size of the set is now = " << tempSet.size() << " maps." << endl;
1359 
1360  }
1361 
1362  bool cleanedOneMap = false;
1363 
1364  // cleaning needed if the set has at least two maps
1365 
1366  while(! cleanedOneMap && tempSet.size() > 1) {
1367 
1368  cleanedOneMap=false;
1369 
1370  //LogTrace("FourVectorHLTOffline") << "cleaning: size of the set = " << tempSet.size() << " maps." << endl;
1371 
1372  int imap = 0;
1373  for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ ) {
1374 
1375  fimmap tempMap_j = *setIter_i;
1376 
1377  //LogTrace("FourVectorHLTOffline") << " map " << imap << endl;
1378  //LogTrace("FourVectorHLTOffline") << " --------" << endl;
1379 
1380  for (fimmap::iterator it = tempMap_j.begin(); it != tempMap_j.end(); ++it) {
1381 
1382  //LogTrace("FourVectorHLTOffline") << " " << (*it).first << " : " << (*it).second << endl;
1383 
1384  }
1385 
1386  imap++;
1387 
1388  }
1389 
1390  // loop i
1391  for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ ) {
1392 
1393  fimmap tempMap_i = *setIter_i;
1394  fimmap::iterator it = tempMap_i.begin();
1395  int topValue = (*it).second;
1396  //LogTrace("FourVectorHLTOffline") << " topValue = " << topValue << endl;
1397 
1398 
1399  mmset::iterator tempIter_i = setIter_i;
1400 
1401  // from all the other maps, clean entries that have mapped value "topValue"
1402  // loop j
1403  mmset::iterator setIter_j = ++tempIter_i;
1404  while ( setIter_j != tempSet.end( ) ) {
1405 
1406  fimmap tempMap_j = *setIter_j;
1407  //LogTrace("FourVectorHLTOffline") << " size of the map = " << tempMap_j.size() << endl;
1408 
1409  fimmap::iterator it = tempMap_j.begin();
1410  while ( it != tempMap_j.end() ) {
1411 
1412  if(topValue == (*it).second) {
1413 
1414  //LogTrace("FourVectorHLTOffline") << " Ridding map of a doubly-matched object." << endl;
1415  fimmap::iterator tempIt = it;
1416  ++it; //no longer points to item that is going away
1417  tempMap_j.erase(tempIt);
1418  cleanedOneMap = true;
1419 
1420  } else {
1421  ++it;
1422  } // end if
1423 
1424  } //end while
1425 
1426  if(cleanedOneMap) {
1427 
1428  //remove the old map from the set
1429  mmset::iterator tempIt = setIter_j;
1430  ++setIter_j; //no longer points to item that is going away
1431  tempSet.erase(tempIt);
1432 
1433  // insert in the set the new map if it is not an empty map
1434  if(! tempMap_j.empty()) tempSet.insert(tempMap_j);
1435 
1436  break; // break from loop j
1437 
1438  } else {
1439  ++setIter_j;
1440  } // end if
1441 
1442 
1443  }// end while j
1444 
1445  if(cleanedOneMap) break; // break from loop i
1446 
1447  } // end loop i
1448 
1449  if(cleanedOneMap) {
1450 
1451  // continue cleaning (in while loop)
1452  // but reset flag first
1453  cleanedOneMap=false;
1454  continue;
1455 
1456  }
1457  else {
1458 
1459  // finished cleaing (break from while loop)
1460  break;
1461 
1462  }
1463 
1464  } // end while
1465 
1466  //LogTrace("FourVectorHLTOffline") << "cleaned: size of the set = " << tempSet.size() << " maps." << endl;
1467  int jmap = 0;
1468 
1469  for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ )
1470  {
1471 
1472  fimmap tempMap_j = *setIter_i;
1473 
1474  //LogTrace("FourVectorHLTOffline") << " map " << jmap << endl;
1475  //LogTrace("FourVectorHLTOffline") << " --------" << endl;
1476 
1477  for (fimmap::iterator it = tempMap_j.begin(); it != tempMap_j.end(); ++it) {
1478 
1479  //LogTrace("FourVectorHLTOffline") << " " << (*it).first << " : " << (*it).second << endl;
1480 
1481  }
1482 
1483  jmap++;
1484 
1485  } // end for
1486 
1487  return;
1488 
1489 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
i
int i
Definition: DBlmapReader.cc:9
fimmap
std::multimap< float, int > fimmap
Definition: FourVectorHLTOnline.h:72
void FourVectorHLTOffline::countHLTGroupBXHitsEndLumiBlock ( const int &  lumi)
private

Definition at line 1798 of file FourVectorHLTOffline.cc.

References b, plotTTrigFromHistos::binNumber(), runGlobalFakeInputProducer::bxOffset, fGroupNamePathsPair, fPathBxTempCountPair, MonitorElement::getTH2F(), j, gen::k, LogDebug, LogTrace, ME_HLT_BX, Nbx_, timingPdfMaker::pathname, referenceBX_, edm::second(), findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, v_ME_Total_BX, and v_ME_Total_BX_Norm.

1799 {
1800 
1801  LogTrace("FourVectorHLTOffline") << " countHLTGroupBXHitsEndLumiBlock() lumiSection number " << lumi << endl;
1802 
1803  TH2F * hist_2d_bx = ME_HLT_BX->getTH2F();
1804 
1805  for (std::vector<std::pair<std::string, vector<int> > >::iterator ip = fPathBxTempCountPair.begin(); ip != fPathBxTempCountPair.end(); ++ip) {
1806 
1807  // get the path and its previous count
1808  std::string pathname = ip->first;
1809  vector<int> prevCount = ip->second;
1810 
1811  // vector of 5 zeros
1812  vector<int> currCount (5,0);
1813  vector<int> diffCount (5,0);
1814 
1815  // get the current count of path up to now
1816  int pathBin = hist_2d_bx->GetYaxis()->FindBin(pathname.c_str());
1817 
1818  if(pathBin > hist_2d_bx->GetNbinsY()) {
1819 
1820  LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
1821  continue;
1822 
1823  }
1824 
1825  for (unsigned int b =0;b<currCount.size();b++) {
1826 
1827  int bxOffset = b-2;
1828  int bunch = referenceBX_+bxOffset;
1829  if(bunch < 1) bunch += Nbx_ ;
1830  int bxBin = bunch +1; // add one to get the right bin
1831 
1832 
1833  currCount[b] = int(hist_2d_bx->GetBinContent(bxBin, pathBin)); // add one to get the right bin
1834 
1835  LogTrace("FourVectorHLTOffline") << "currCount = " << currCount[b] << endl;
1836 
1837  // count due to prev lumi sec is a difference bw current and previous
1838  diffCount[b] = currCount[b] - prevCount[b];
1839 
1840  LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << " path " << pathname << "bxOffset = " << bxOffset << " count = " << diffCount[b] << endl;
1841 
1842  } // end for bx b
1843 
1844  // set the counter in the pair to current count
1845  ip->second = currCount;
1846 
1848  // fill the 2D Group paths' BX count per LS, using currCount
1850  LogTrace("FourVectorHLTOffline") << "Find " << pathname << endl;
1851 
1852  //check if the path is in this group
1853  for (unsigned int j=0;j<fGroupNamePathsPair.size();j++) {
1854 
1855  bool isMember = false;
1856 
1857  LogTrace("FourVectorHLTOffline") << " ---- Group " << fGroupNamePathsPair[j].first << endl;
1858 
1859  // decide if pathname is member of this group
1860  for (unsigned int k = 0; k<(fGroupNamePathsPair[j].second).size();k++) {
1861 
1862  LogTrace("FourVectorHLTOffline") << " comparing to " << fGroupNamePathsPair[j].second[k] << endl;
1863 
1864  if(fGroupNamePathsPair[j].second[k] == pathname) {
1865 
1866  isMember = true;
1867  break;
1868 
1869  }
1870 
1871  } // end for k
1872 
1873  if(!isMember) {
1874 
1875  LogTrace("FourVectorHLTOffline") << "Could not find a group to which the path belongs, path = " << pathname << " group = " << fGroupNamePathsPair[j].first << endl;
1876  continue;
1877 
1878  }
1879 
1880  MonitorElement* ME_2d = v_ME_Total_BX[j];
1881 
1882  if (! ME_2d) {
1883 
1884  LogDebug("FourVectorHLTOffline") << " cannot find ME_2d for group " << fGroupNamePathsPair[j].first << endl;
1885  continue;
1886 
1887  }
1888 
1889  vector<int> updatedLumiCount(5,0);
1890 
1891  float entireBXWindowUpdatedLumiCount = 0;
1892 
1893  TH2F* hist_All = ME_2d->getTH2F();
1894 
1895  for (unsigned int b = 0; b<diffCount.size();b++) {
1896 
1897  // find the bin
1898  int binNumber = b+1; // add one to get right bin
1899 
1900  // update the bin content (must do that since events don't ncessarily come in the order
1901  int currentLumiCount = int(hist_All->GetBinContent(lumi+1,binNumber));
1902  updatedLumiCount[b] = currentLumiCount + diffCount[b];
1903  hist_All->SetBinContent(lumi+1,binNumber,updatedLumiCount[b]);
1904 
1905  entireBXWindowUpdatedLumiCount += updatedLumiCount[b];
1906 
1907  } // end for bx b
1908 
1909  MonitorElement* ME_2d_Norm = v_ME_Total_BX_Norm[j];
1910 
1911  if (! ME_2d_Norm) {
1912 
1913  LogDebug("FourVectorHLTOffline") << " cannot find ME_2d_Norm for group " << fGroupNamePathsPair[j].first << endl;
1914  continue;
1915 
1916  }
1917 
1918  TH2F* hist_All_Norm = ME_2d_Norm->getTH2F();
1919 
1920  for (unsigned int b = 0; b<diffCount.size();b++) {
1921 
1922  // find the bin
1923  int binNumber = b+1; // add one to get right bin
1924 
1925  // update the bin content but normalized to the whole columb (BX windw +/- 2)
1926  if(entireBXWindowUpdatedLumiCount != 0)
1927  hist_All_Norm->SetBinContent(lumi+1,binNumber,float(updatedLumiCount[b])/entireBXWindowUpdatedLumiCount);
1928 
1929  } // end for bx b
1930 
1931  } // end for group j
1932 
1933  } // end for ip
1934 
1935 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
FourVectorHLTOffline::fPathBxTempCountPair
std::vector< std::pair< std::string, std::vector< int > > > fPathBxTempCountPair
Definition: FourVectorHLTOffline.h:317
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
FourVectorHLTOffline::v_ME_Total_BX
std::vector< MonitorElement * > v_ME_Total_BX
Definition: FourVectorHLTOffline.h:182
j
int j
Definition: DBlmapReader.cc:9
FourVectorHLTOffline::v_ME_Total_BX_Norm
std::vector< MonitorElement * > v_ME_Total_BX_Norm
Definition: FourVectorHLTOffline.h:183
FourVectorHLTOffline::ME_HLT_BX
MonitorElement * ME_HLT_BX
Definition: FourVectorHLTOffline.h:179
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:79
b
double b
Definition: hdecay.h:120
FourVectorHLTOffline::fGroupNamePathsPair
std::vector< std::pair< std::string, std::vector< std::string > > > fGroupNamePathsPair
Definition: FourVectorHLTOffline.h:320
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1522
findQualityFiles.size
tuple size
Write out results.
Definition: findQualityFiles.py:442
void FourVectorHLTOffline::countHLTGroupHitsEndLumiBlock ( const int &  lumi)
private

Definition at line 2016 of file FourVectorHLTOffline.cc.

References dbe_, fGroupNamePathsPair, fGroupTempCountPair, DQMStore::get(), MonitorElement::getTH1(), MonitorElement::getTH1F(), i, LogDebug, LogTrace, LSsize_, timingPdfMaker::pathname, and pathsSummaryHLTPathsPerLSFolder_.

Referenced by endLuminosityBlock().

2017 {
2018 
2019  LogTrace("FourVectorHLTOffline") << " countHLTGroupHitsEndLumiBlock() lumiSection number " << lumi << endl;
2020  for(unsigned int i=0; i<fGroupNamePathsPair.size(); i++){
2021 
2022  // get the count of path up to now
2023  string fullPathToME = "HLT/FourVector/PathsSummary/HLT_" + fGroupNamePathsPair[i].first + "_Pass_Any";
2024  MonitorElement* ME_1d = dbe_->get(fullPathToME);
2025 
2026  if(! ME_1d) {
2027 
2028  LogTrace("FourVectorHLTOffline") << " could not find 1d matrix " << fullPathToME << endl;
2029 
2030  continue;
2031 
2032  }
2033 
2034  LogTrace("FourVectorHLTOffline") << " Looking in histogram " << fullPathToME << endl;
2035 
2036  TH1F * hist_1d = ME_1d->getTH1F();
2037 
2038  for (std::vector<std::pair<std::string, float> >::iterator ip = fGroupTempCountPair.begin(); ip != fGroupTempCountPair.end(); ++ip) {
2039 
2040  // get the path and its previous count
2041  string pathname = ip->first;
2042  float prevCount = ip->second;
2043 
2044  string binLabel = "HLT_"+pathname+"_Any";
2045 
2046  LogTrace("FourVectorHLTOffline") << " Looking for binLabel = " << binLabel << endl;
2047  // get the current count of path up to now
2048  int pathBin = hist_1d->GetXaxis()->FindBin(binLabel.c_str());
2049 
2050  LogTrace("FourVectorHLTOffline") << " pathBin = " << pathBin << " out of histogram total number of bins " << hist_1d->GetNbinsX() << endl;
2051  if(pathBin == -1) {
2052 
2053  LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
2054  continue;
2055 
2056  }
2057 
2058  float currCount = hist_1d->GetBinContent(pathBin)/LSsize_;
2059 
2060  // count due to prev lumi sec is a difference bw current and previous
2061  float diffCount = currCount - prevCount;
2062 
2063  LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << " path " << pathname << " count " << diffCount << endl;
2064 
2065  // set the counter in the pair to current count
2066  ip->second = currCount;
2067 
2068 
2070  // fill the 1D individual path count per LS
2072  string fullPathToME_count = pathsSummaryHLTPathsPerLSFolder_ +"HLT_" + pathname + "_Total_LS";
2073  MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
2074  if ( ME_1d) {
2075 
2076  // update the bin content (must do that since events don't ncessarily come in the order
2077  float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
2078  float updatedLumiCount = currentLumiCount + diffCount;
2079  ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);
2080 
2081  }
2082  else {
2083 
2084  LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count << endl;
2085 
2086  }
2087 
2088  } // end for ip
2089 
2090  } // end for i
2091 
2092 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
i
int i
Definition: DBlmapReader.cc:9
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
FourVectorHLTOffline::pathsSummaryHLTPathsPerLSFolder_
std::string pathsSummaryHLTPathsPerLSFolder_
Definition: FourVectorHLTOffline.h:189
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1491
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1679
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1498
FourVectorHLTOffline::fGroupTempCountPair
std::vector< std::pair< std::string, float > > fGroupTempCountPair
Definition: FourVectorHLTOffline.h:318
FourVectorHLTOffline::fGroupNamePathsPair
std::vector< std::pair< std::string, std::vector< std::string > > > fGroupNamePathsPair
Definition: FourVectorHLTOffline.h:320
void FourVectorHLTOffline::countHLTGroupL1HitsEndLumiBlock ( const int &  lumi)
private

Definition at line 1937 of file FourVectorHLTOffline.cc.

References dbe_, fGroupL1TempCountPair, fGroupNamePathsPair, DQMStore::get(), MonitorElement::getTH1(), MonitorElement::getTH1F(), i, LogDebug, LogTrace, LSsize_, timingPdfMaker::pathname, and pathsSummaryHLTPathsPerLSFolder_.

Referenced by endLuminosityBlock().

1938 {
1939 
1940  LogTrace("FourVectorHLTOffline") << " countHLTGroupL1HitsEndLumiBlock() lumiSection number " << lumi << endl;
1941 
1942  for(unsigned int i=0; i<fGroupNamePathsPair.size(); i++){
1943 
1944  // get the count of path up to now
1945  string fullPathToME = "HLT/FourVector/PathsSummary/HLT_" + fGroupNamePathsPair[i].first+ "_Pass_Any";
1946  MonitorElement* ME_1d = dbe_->get(fullPathToME);
1947 
1948  if(! ME_1d) {
1949 
1950  LogTrace("FourVectorHLTOffline") << " could not find 1d matrix " << fullPathToME << endl;
1951 
1952  continue;
1953 
1954  }
1955 
1956  LogTrace("FourVectorHLTOffline") << " Looking in histogram " << fullPathToME << endl;
1957 
1958  TH1F * hist_1d = ME_1d->getTH1F();
1959 
1960  for (std::vector<std::pair<std::string, float> >::iterator ip = fGroupL1TempCountPair.begin(); ip != fGroupL1TempCountPair.end(); ++ip) {
1961 
1962  // get the path and its previous count
1963  string pathname = ip->first;
1964  float prevCount = ip->second;
1965 
1966  string binLabel = "HLT_"+pathname+"_L1_Any";
1967 
1968  LogTrace("FourVectorHLTOffline") << " Looking for binLabel = " << binLabel << endl;
1969  // get the current count of path up to now
1970  int pathBin = hist_1d->GetXaxis()->FindBin(binLabel.c_str());
1971 
1972  LogTrace("FourVectorHLTOffline") << " pathBin = " << pathBin << " out of histogram total number of bins " << hist_1d->GetNbinsX() << endl;
1973  if(pathBin == -1) {
1974 
1975  LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
1976  continue;
1977 
1978  }
1979 
1980  float currCount = hist_1d->GetBinContent(pathBin)/LSsize_;
1981 
1982  // count due to prev lumi sec is a difference bw current and previous
1983  float diffCount = currCount - prevCount;
1984 
1985  LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << " path " << pathname << " count " << diffCount << endl;
1986 
1987  // set the counter in the pair to current count
1988  ip->second = currCount;
1989 
1990 
1992  // fill the 1D individual path count per LS
1994  string fullPathToME_count = pathsSummaryHLTPathsPerLSFolder_ +"HLT_" + pathname + "_L1_Total_LS";
1995  MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
1996  if ( ME_1d) {
1997 
1998  // update the bin content (must do that since events don't ncessarily come in the order
1999  float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
2000  float updatedLumiCount = currentLumiCount + diffCount;
2001  ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);
2002  }
2003  else {
2004 
2005  LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count << endl;
2006 
2007  }
2008 
2009  } // end for ip
2010 
2011  } // end for i
2012 
2013 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
i
int i
Definition: DBlmapReader.cc:9
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
FourVectorHLTOffline::pathsSummaryHLTPathsPerLSFolder_
std::string pathsSummaryHLTPathsPerLSFolder_
Definition: FourVectorHLTOffline.h:189
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1491
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1679
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1498
FourVectorHLTOffline::fGroupNamePathsPair
std::vector< std::pair< std::string, std::vector< std::string > > > fGroupNamePathsPair
Definition: FourVectorHLTOffline.h:320
FourVectorHLTOffline::fGroupL1TempCountPair
std::vector< std::pair< std::string, float > > fGroupL1TempCountPair
Definition: FourVectorHLTOffline.h:319
void FourVectorHLTOffline::countHLTPathHitsEndLumiBlock ( const int &  lumi)
private

Definition at line 2095 of file FourVectorHLTOffline.cc.

References dbe_, fPathTempCountPair, DQMStore::get(), MonitorElement::getTH2F(), LogDebug, LogTrace, LSsize_, ME_HLTAll_LS, timingPdfMaker::pathname, and AlCaHLTBitMon_QueryRunRegistry::string.

2096 {
2097 
2098  LogTrace("FourVectorHLTOffline") << " countHLTPathHitsEndLumiBlock() lumiSection number " << lumi << endl;
2099  // get the count of path up to now
2100  string fullPathToME = "HLT/FourVector/PathsSummary/HLT_All_PassPass";
2101  MonitorElement* ME_2d = dbe_->get(fullPathToME);
2102 
2103  if(! ME_2d) {
2104 
2105  LogTrace("FourVectorHLTOffline") << " could not fine 2d matrix " << fullPathToME << endl;
2106 
2107  return;
2108 
2109  }
2110 
2111  TH2F * hist_2d = ME_2d->getTH2F();
2112 
2113  for (std::vector<std::pair<std::string, float> >::iterator ip = fPathTempCountPair.begin(); ip != fPathTempCountPair.end(); ++ip) {
2114 
2115  // get the path and its previous count
2116  std::string pathname = ip->first;
2117  float prevCount = ip->second;
2118 
2119  // get the current count of path up to now
2120  float pathBin = hist_2d->GetXaxis()->FindBin(pathname.c_str());
2121 
2122  if(pathBin > hist_2d->GetNbinsX()) {
2123 
2124  LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
2125  continue;
2126 
2127  }
2128 
2129  float currCount = hist_2d->GetBinContent(pathBin, pathBin)/LSsize_;
2130 
2131  // count due to prev lumi sec is a difference bw current and previous
2132  float diffCount = currCount - prevCount;
2133 
2134  LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << " path " << pathname << " count " << diffCount << endl;
2135 
2136  // set the counter in the pair to current count
2137  ip->second = currCount;
2138 
2140  // fill the 2D All paths' count per LS
2142  if ( ME_HLTAll_LS) {
2143 
2144  TH2F* hist_All = ME_HLTAll_LS->getTH2F();
2145 
2146  // find the bin
2147  int pathBinNumber = hist_All->GetYaxis()->FindBin(pathname.c_str());
2148 
2149  // update the bin content (must do that since events don't ncessarily come in the order
2150  float currentLumiCount = hist_All->GetBinContent(lumi+1,pathBinNumber);
2151  float updatedLumiCount = currentLumiCount + diffCount;
2152  hist_All->SetBinContent(lumi+1,pathBinNumber,updatedLumiCount);
2153 
2154  }
2155  else {
2156 
2157  LogDebug("FourVectorHLTOffline") << " cannot find ME_HLTAll_LS" << endl;
2158 
2159  }
2160 
2161 // for (unsigned int i=0 ; i< v_ME_HLTAll_LS.size(); i++) {
2162 
2163 // MonitorElement* tempME = v_ME_HLTAll_LS[i];
2164 
2165 // if (tempME && tempME->getName().find(pathname) != std::string::npos) {
2166 
2167 // TH1F* hist_All = tempME->getTH1F();
2168 
2169 // // // find the bin
2170 // // int pathBinNumber = hist_All->GetYaxis()->FindBin(pathname.c_str());
2171 // // // update the bin content (must do that since events don't ncessarily come in the order
2172 // float currentLumiCount = hist_All->GetBinContent(lumi+1);
2173 // float updatedLumiCount = currentLumiCount + diffCount;
2174 // hist_All->SetBinContent(lumi+1,updatedLumiCount);
2175 
2176 // }
2177 // else {
2178 
2179 // LogDebug("FourVectorHLTOffline") << " cannot find tempME " << endl;
2180 
2181 // }
2182 
2183 // }
2184 
2185 
2186  // bjk here
2187 // ///////////////////////////////////////////
2188 // // fill the 1D individual path count per LS
2189 // ///////////////////////////////////////////
2190 // string fullPathToME_count = pathsIndividualHLTPathsPerLSFolder_ + pathname + "_count_per_LS";
2191 // MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
2192 // if ( ME_1d) {
2193 
2194 // // update the bin content (must do that since events don't ncessarily come in the order
2195 // float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
2196 // float updatedLumiCount = currentLumiCount + diffCount;
2197 // ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);
2198 
2199 // }
2200 // else {
2201 
2202 // LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count << endl;
2203 
2204 // }
2205 
2206  } // end for ip
2207 
2208 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
FourVectorHLTOffline::fPathTempCountPair
std::vector< std::pair< std::string, float > > fPathTempCountPair
Definition: FourVectorHLTOffline.h:316
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1679
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
FourVectorHLTOffline::ME_HLTAll_LS
MonitorElement * ME_HLTAll_LS
Definition: FourVectorHLTOffline.h:178
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1522
void FourVectorHLTOffline::endJob ( void  )
privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 753 of file FourVectorHLTOffline.cc.

References nev_.

754 {
755  LogInfo("FourVectorHLTOffline") << "analyzed " << nev_ << " events";
756  return;
757 }
void FourVectorHLTOffline::endLuminosityBlock ( const edm::LuminosityBlock &  lumiSeg,
const edm::EventSetup &  c 
)
privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1783 of file FourVectorHLTOffline.cc.

References countHLTGroupHitsEndLumiBlock(), countHLTGroupL1HitsEndLumiBlock(), edm::LuminosityBlockBase::id(), LogTrace, fjr2json::lumi, and edm::LuminosityBlockID::luminosityBlock().

1784 {
1785 
1786  int lumi = int(lumiSeg.id().luminosityBlock());
1787  LogTrace("FourVectorHLTOffline") << " end lumiSection number " << lumi << endl;
1788 
1789  // countHLTPathHitsEndLumiBlock(lumi);
1790  countHLTGroupHitsEndLumiBlock(lumi);
1791  countHLTGroupL1HitsEndLumiBlock(lumi);
1792 
1793  // countHLTGroupBXHitsEndLumiBlock(lumi);
1794 
1795 }
edm::LuminosityBlockBase::id
LuminosityBlockID id() const
Definition: LuminosityBlockBase.h:53
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
FourVectorHLTOffline::countHLTGroupL1HitsEndLumiBlock
void countHLTGroupL1HitsEndLumiBlock(const int &lumi)
Definition: FourVectorHLTOffline.cc:1937
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
edm::LuminosityBlockID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockID.h:43
FourVectorHLTOffline::countHLTGroupHitsEndLumiBlock
void countHLTGroupHitsEndLumiBlock(const int &lumi)
Definition: FourVectorHLTOffline.cc:2016
void FourVectorHLTOffline::endRun ( const edm::Run &  run,
const edm::EventSetup &  c 
)
privatevirtual

EndRun.

Reimplemented from edm::EDAnalyzer.

Definition at line 1337 of file FourVectorHLTOffline.cc.

References edm::RunBase::id(), and LogDebug.

1338 {
1339 
1340  LogDebug("FourVectorHLTOffline") << "endRun, run " << run.id();
1341 
1342 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
edm::RunBase::id
RunID const & id() const
Definition: RunBase.h:41
void FourVectorHLTOffline::fillHltMatrix ( const edm::TriggerNames &  triggerNames)
private

Definition at line 1588 of file FourVectorHLTOffline.cc.

References dbe_, fGroupNamePathsPair, fTriggerResults, DQMStore::get(), MonitorElement::getTH1F(), MonitorElement::getTH2F(), i, j, LogTrace, edm::second(), and edm::TriggerNames::triggerIndex().

Referenced by analyze().

1588  {
1589 
1590 
1591  string fullPathToME;
1592 
1593  //for (unsigned int mi=0;mi<fGroupName.size();mi++) {
1594  for (unsigned int mi=0;mi<fGroupNamePathsPair.size();mi++) {
1595 
1596 
1597  fullPathToME = "HLT/FourVector/PathsSummary/HLT_"+fGroupNamePathsPair[mi].first+"_PassPass";
1598  MonitorElement* ME_2d = dbe_->get(fullPathToME);
1599  fullPathToME = "HLT/FourVector/PathsSummary/HLT_"+fGroupNamePathsPair[mi].first+"_Pass_Any";
1600  MonitorElement* ME_1d = dbe_->get(fullPathToME);
1601  if(!ME_2d || !ME_1d) {
1602 
1603  LogTrace("FourVectorHLTOffline") << " ME not valid although I gave full path" << endl;
1604  continue;
1605 
1606  }
1607 
1608  TH2F * hist_2d = ME_2d->getTH2F();
1609  TH1F * hist_1d = ME_1d->getTH1F();
1610 
1611  // Fill HLTPassed Matrix bin (i,j) = (Any,Any)
1612  // --------------------------------------------------------
1613  int anyBinNumber = hist_2d->GetXaxis()->FindBin("HLT_Any");
1614 
1615  string groupBinLabel = "HLT_"+fGroupNamePathsPair[mi].first+"_Any";
1616  int groupBinNumber = hist_2d->GetXaxis()->FindBin(groupBinLabel.c_str());
1617 
1618  // any trigger accepted
1619  if(fTriggerResults->accept()){
1620 
1621  hist_2d->Fill(anyBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter
1622  hist_1d->Fill(anyBinNumber-1);//binNumber1 = 0 = first filter
1623 
1624  }
1625 
1626  bool groupPassed = false;
1627  //bool groupL1Passed = false;
1628 
1629  // Main loop over paths
1630  // --------------------
1631 
1632  //for (int i=1; i< hist_2d->GetNbinsX();i++)
1633  for (unsigned int i=0; i< fGroupNamePathsPair[mi].second.size(); i++)
1634  {
1635 
1636  //string hltPathName = hist_2d->GetXaxis()->GetBinLabel(i);
1637  string hltPathName = fGroupNamePathsPair[mi].second[i];
1638 
1639  // check if this is hlt path name
1640  //unsigned int pathByIndex = triggerNames.triggerIndex(hltPathName);
1641  unsigned int pathByIndex = triggerNames.triggerIndex(fGroupNamePathsPair[mi].second[i]);
1642  if(pathByIndex >= fTriggerResults->size() ) continue;
1643 
1644  // check if its L1 passed
1645  // comment out below but set groupL1Passed to true always
1646  //if(hasL1Passed(hltPathName,triggerNames)) groupL1Passed = true;
1647  //groupL1Passed = true;
1648 
1649  // Fill HLTPassed Matrix and HLTPassFail Matrix
1650  // --------------------------------------------------------
1651 
1652  if(fTriggerResults->accept(pathByIndex)){
1653 
1654  groupPassed = true;
1655  //groupL1Passed = true;
1656 
1657  hist_2d->Fill(i,anyBinNumber-1);//binNumber1 = 0 = first filter
1658  hist_2d->Fill(anyBinNumber-1,i);//binNumber1 = 0 = first filter
1659 
1660  hist_2d->Fill(i,groupBinNumber-1);//binNumber1 = 0 = first filter
1661  hist_2d->Fill(groupBinNumber-1,i);//binNumber1 = 0 = first filter
1662 
1663  hist_1d->Fill(i);//binNumber1 = 0 = first filter
1664 
1665 
1666  //for (int j=1; j< hist_2d->GetNbinsY();j++)
1667  for (unsigned int j=0; j< fGroupNamePathsPair[mi].second.size(); j++)
1668  {
1669 
1670  string crossHltPathName = fGroupNamePathsPair[mi].second[j];
1671 
1672  //unsigned int crosspathByIndex = triggerNames.triggerIndex(hist_2d->GetXaxis()->GetBinLabel(j));
1673  //unsigned int crosspathByIndex = triggerNames.triggerIndex(crossHltPathName);
1674  unsigned int crosspathByIndex = triggerNames.triggerIndex(fGroupNamePathsPair[mi].second[j]);
1675 
1676  if(crosspathByIndex >= fTriggerResults->size() ) continue;
1677 
1678  if(fTriggerResults->accept(crosspathByIndex)){
1679 
1680  hist_2d->Fill(i,j);//binNumber1 = 0 = first filter
1681 
1682  } // end if j path passed
1683 
1684  } // end for j
1685 
1686  } // end if i passed
1687 
1688 
1689  } // end for i
1690 
1691  if(groupPassed) {
1692 
1693  hist_1d->Fill(groupBinNumber-1);//binNumber1 = 0 = first filter
1694  hist_1d->Fill(groupBinNumber-2);//binNumber1 = 0 = first filter -> Fill L1group as well
1695  hist_2d->Fill(groupBinNumber-1,groupBinNumber-1);//binNumber1 = 0 = first filter
1696  hist_2d->Fill(anyBinNumber-1,groupBinNumber-1);//binNumber1 = 0 = first filter
1697  hist_2d->Fill(groupBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter
1698 
1699  }
1700 
1701  /*
1702  string groupL1BinLabel = "HLT_"+fGroupNamePathsPair[mi].first+"_L1_Any";
1703  int groupL1BinNumber = hist_2d->GetXaxis()->FindBin(groupL1BinLabel.c_str());
1704 
1705  if(groupL1Passed) hist_1d->Fill(groupL1BinNumber-1);//binNumber1 = 0 = first filter
1706  */
1707  } // end for mi
1708 
1709 }
i
int i
Definition: DBlmapReader.cc:9
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
FourVectorHLTOffline::fTriggerResults
edm::Handle< edm::TriggerResults > fTriggerResults
Definition: FourVectorHLTOffline.h:122
j
int j
Definition: DBlmapReader.cc:9
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1679
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1498
FourVectorHLTOffline::fGroupNamePathsPair
std::vector< std::pair< std::string, std::vector< std::string > > > fGroupNamePathsPair
Definition: FourVectorHLTOffline.h:320
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1522
int FourVectorHLTOffline::getHltThresholdFromName ( const std::string &  pathname)
private

Definition at line 2550 of file FourVectorHLTOffline.cc.

References i, mergeVDriftHistosByStation::name, timingPdfMaker::pathname, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by beginRun().

2551 {
2552 
2553  std::string pathname = name;
2554  //cout << "----------------------------------------------" << endl;
2555  //cout << pathname << endl;
2556 
2557  //remove "L1" substr
2558  if(pathname.find("L1") != std::string::npos) pathname.replace(pathname.find("L1"),2,"");
2559  //remove "L2" substr
2560  if(pathname.find("L2") != std::string::npos) pathname.replace(pathname.find("L2"),2,"");
2561  //remove "8E29" substr
2562  if(pathname.find("8E29") != std::string::npos) pathname.replace(pathname.find("8E29"),4,"");
2563 
2564  int digitLocation=0;
2565  for (unsigned int i=0; i < pathname.length(); i++)
2566  {
2567  if (isdigit(pathname.at(i))) {
2568 
2569  digitLocation = i;
2570  break;
2571 
2572  }
2573  }
2574 
2575  // get the string from the location of the first digit to the end
2576  string hltThresholdString = pathname.substr(digitLocation);
2577 
2578  int hltThreshold = 0;
2579 
2580  // get intiger at the begining of the string
2581  sscanf (hltThresholdString.c_str(),"%d%*s",&hltThreshold);
2582  //printf ("%s -> %s -> %d\n",pathname.c_str(), hltThresholdString.c_str(), hltThreshold);
2583 
2584  return hltThreshold;
2585 
2586 }
i
int i
Definition: DBlmapReader.cc:9
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
const string FourVectorHLTOffline::getL1ConditionModuleName ( const std::string &  pathname)
private

Definition at line 2241 of file FourVectorHLTOffline.cc.

References hltConfig_, HLTConfigProvider::moduleLabels(), and HLTConfigProvider::moduleType().

Referenced by beginRun().

2242 {
2243 
2244  // find L1 condition for numpath with numpath objecttype
2245  // find PSet for L1 global seed for numpath,
2246  // list module labels for numpath
2247  string l1pathname = "dummy";
2248 
2249  vector<string> numpathmodules = hltConfig_.moduleLabels(pathname);
2250 
2251  for(vector<string>::iterator numpathmodule = numpathmodules.begin();
2252  numpathmodule!= numpathmodules.end(); ++numpathmodule ) {
2253 
2254  if (hltConfig_.moduleType(*numpathmodule) == "HLTLevel1GTSeed") {
2255 
2256  l1pathname = *numpathmodule;
2257  break;
2258 
2259  }
2260 
2261  } // end for
2262 
2263  return l1pathname;
2264 
2265 }
HLTConfigProvider::moduleType
const std::string moduleType(const std::string &module) const
C++ class name of module.
Definition: HLTConfigProvider.h:141
FourVectorHLTOffline::hltConfig_
HLTConfigProvider hltConfig_
Definition: FourVectorHLTOffline.h:355
HLTConfigProvider::moduleLabels
const std::vector< std::string > & moduleLabels(unsigned int trigger) const
label(s) of module(s) on a trigger path
Definition: HLTConfigProvider.h:113
int FourVectorHLTOffline::getTriggerTypeParsePathName ( const std::string &  pathname)
private

Definition at line 2210 of file FourVectorHLTOffline.cc.

References trigger::TriggerBJet, trigger::TriggerElectron, trigger::TriggerJet, trigger::TriggerMET, trigger::TriggerMuon, trigger::TriggerPhoton, trigger::TriggerTau, trigger::TriggerTET, and trigger::TriggerTrack.

Referenced by beginRun().

2211 {
2212 
2213  int objectType = 0;
2214 
2215  if (pathname.find("MET") != std::string::npos)
2216  objectType = trigger::TriggerMET;
2217  if (pathname.find("SumET") != std::string::npos || pathname.find("SumEt") != std::string::npos || pathname.find("ETT") != std::string::npos)
2218  objectType = trigger::TriggerTET;
2219  if (pathname.find("HT") != std::string::npos)
2220  objectType = trigger::TriggerTET;
2221  if (pathname.find("Jet") != std::string::npos)
2222  objectType = trigger::TriggerJet;
2223  if (pathname.find("Mu") != std::string::npos)
2224  objectType = trigger::TriggerMuon;
2225  if (pathname.find("Ele") != std::string::npos)
2226  objectType = trigger::TriggerElectron;
2227  if (pathname.find("Photon") != std::string::npos)
2228  objectType = trigger::TriggerPhoton;
2229  if (pathname.find("EG") != std::string::npos)
2230  objectType = trigger::TriggerPhoton;
2231  if (pathname.find("Tau") != std::string::npos)
2232  objectType = trigger::TriggerTau;
2233  if (pathname.find("IsoTrack") != std::string::npos)
2234  objectType = trigger::TriggerTrack;
2235  if (pathname.find("BTag") != std::string::npos)
2236  objectType = trigger::TriggerBJet;
2237 
2238  return objectType;
2239 }
bool FourVectorHLTOffline::hasHLTPassed ( const std::string &  pathname,
const edm::TriggerNames &  triggerNames 
)
private

Definition at line 2294 of file FourVectorHLTOffline.cc.

References fTriggerResults, and edm::TriggerNames::triggerIndex().

2295 {
2296 
2297  bool rc = false;
2298 
2299  unsigned int pathByIndex = triggerNames.triggerIndex(pathname);
2300  if(pathByIndex >= fTriggerResults->size() ) return rc; // path is not in the menu
2301 
2302  rc = fTriggerResults->accept(pathByIndex);
2303 
2304  return rc;
2305 
2306 }
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
FourVectorHLTOffline::fTriggerResults
edm::Handle< edm::TriggerResults > fTriggerResults
Definition: FourVectorHLTOffline.h:122
bool FourVectorHLTOffline::hasL1Passed ( const std::string &  pathname,
const edm::TriggerNames &  triggerNames 
)
private

Definition at line 2268 of file FourVectorHLTOffline.cc.

References fTriggerResults, hltPathsDiagonal_, timingPdfMaker::pathname, edm::TriggerNames::triggerIndex(), and findQualityFiles::v.

2269 {
2270 
2271  bool rc = false;
2272  int l1ModuleIndex = 999;
2273  // --------------------
2274  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
2275 
2276  if(v->getPath() == pathname ) l1ModuleIndex = v->getL1ModuleIndex();
2277 
2278  }
2279 
2280  unsigned int pathByIndex = triggerNames.triggerIndex(pathname);
2281  if(pathByIndex >= fTriggerResults->size() ) return rc; // path is not in the menu
2282 
2283  // get index of the last module that issued the decision
2284  int lastModule = fTriggerResults->index(pathByIndex);
2285 
2286  // if L1 passed, then it must not be the module that
2287  // issued the last decision
2288  rc = (l1ModuleIndex < lastModule);
2289 
2290  return rc;
2291 
2292 }
FourVectorHLTOffline::hltPathsDiagonal_
PathInfoCollection hltPathsDiagonal_
Definition: FourVectorHLTOffline.h:722
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
FourVectorHLTOffline::fTriggerResults
edm::Handle< edm::TriggerResults > fTriggerResults
Definition: FourVectorHLTOffline.h:122
bool FourVectorHLTOffline::isVBTFMuon ( const reco::Muon &  muon)
private

Definition at line 2588 of file FourVectorHLTOffline.cc.

References dxyCut_, fBeamSpotHandle, reco::Muon::globalTrack(), reco::Muon::innerTrack(), reco::Muon::isTrackerMuon(), edm::HandleBase::isValid(), muonHitsCut_, nMatchesCut_, normalizedChi2Cut_, reco::Muon::numberOfMatches(), pixelHitsCut_, and trackerHitsCut_.

Referenced by selectMuons().

2589 {
2590 
2591  reco::TrackRef gm = muon.globalTrack();
2592  reco::TrackRef tk = muon.innerTrack();
2593 
2594  // Quality cuts
2595  // ------------
2596 
2597  // Must have BeamSpot for the 1st qualityCut
2598  if(!fBeamSpotHandle.isValid()) return 0;
2599 
2600  double dxy = gm->dxy(fBeamSpotHandle->position());
2601  double normalizedChi2 = gm->normalizedChi2();
2602  int trackerHits = tk->hitPattern().numberOfValidTrackerHits();
2603  int pixelHits = tk->hitPattern().numberOfValidPixelHits();
2604  int muonHits = gm->hitPattern().numberOfValidMuonHits();
2605  int nMatches = muon.numberOfMatches();
2606 
2607  if (fabs(dxy)>dxyCut_) {return 0;}
2608  // if(plotHistograms_){ h1_["hNormChi2"]->Fill(normalizedChi2);}
2609  if (normalizedChi2>normalizedChi2Cut_) {return 0;}
2610  // if(plotHistograms_){ h1_["hNHits"]->Fill(trackerHits);}
2611  if (trackerHits<trackerHitsCut_) {return 0;}
2612  // if(plotHistograms_){ h1_["hNMuonHits"]->Fill(muonHits);}
2613  if (pixelHits<pixelHitsCut_) {return 0;}
2614  // if(plotHistograms_){ h1_["hNPixelHits"]->Fill(pixelHits);}
2615  if (muonHits<muonHitsCut_) {return 0;}
2616  // if(plotHistograms_){ h1_["hTracker"]->Fill(mu.isTrackerMuon());}
2617  if (!muon.isTrackerMuon()) {return 0;}
2618  // if(plotHistograms_){ h1_["hNMatches"]->Fill(nMatches);}
2619  if (nMatches<nMatchesCut_) {return 0;}
2620 
2621  return true;
2622 
2623 }
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
reco::Muon::isTrackerMuon
bool isTrackerMuon() const
Definition: Muon.h:219
FourVectorHLTOffline::fBeamSpotHandle
edm::Handle< reco::BeamSpot > fBeamSpotHandle
Definition: FourVectorHLTOffline.h:123
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
reco::Muon::numberOfMatches
int numberOfMatches(ArbitrationType type=SegmentAndTrackArbitration) const
get number of chambers with matched segments
Definition: Muon.cc:60
reco::Muon::globalTrack
virtual TrackRef globalTrack() const
reference to Track reconstructed in both tracked and muon detector
Definition: Muon.h:54
string FourVectorHLTOffline::removeVersions ( std::string  histVersion)
private

Definition at line 2625 of file FourVectorHLTOffline.cc.

References cuy::ii, and BeamSplash_cfg::version.

Referenced by beginRun().

2625  {
2626  for (int ii = 100; ii >= 0; ii--) {
2627  string ver = "_v";
2628  string version ="";
2629  stringstream ss;
2630  ss << ver << ii;
2631  ss >> version;
2632 
2633  size_t pos = histVersion.find(version);
2634  if (pos != std::string::npos)
2635  histVersion.erase(pos,version.size());
2636 
2637  }
2638 
2639  return histVersion;
2640  }
cuy.ii
int ii
Definition: cuy.py:588
BeamSplash_cfg.version
tuple version
Definition: BeamSplash_cfg.py:45
void FourVectorHLTOffline::selectElectrons ( const edm::Event &  iEvent,
const edm::EventSetup &  iSetup,
const edm::Handle< reco::GsfElectronCollection > &  eleHandle 
)
private

Definition at line 2333 of file FourVectorHLTOffline.cc.

References deltaEtaSuperClusterTrackAtVtxEB_, deltaEtaSuperClusterTrackAtVtxEC_, deltaPhiSuperClusterTrackAtVtxEB_, deltaPhiSuperClusterTrackAtVtxEC_, dr03TkSumPtEB_, dr03TkSumPtEC_, dr04EcalRecHitSumEtEB_, dr04EcalRecHitSumEtEC_, dr04HcalTowerSumEtEB_, dr04HcalTowerSumEtEC_, eleMaxOver3x3_, fSelectedElectrons, fSelElectronsHandle, edm::Event::getByToken(), hadronicOverEmEB_, hadronicOverEmEC_, edm::HandleBase::isValid(), edm::HandleBase::provenance(), recHitsEBToken, recHitsEEToken, reco::CaloCluster::seed(), sigmaIetaIetaEB_, sigmaIetaIetaEC_, sigmaIetaIetaSpikesEB_, and sigmaIetaIetaSpikesEC_.

Referenced by analyze().

2334 {
2335 
2336  // for every event, first clear vector of selected objects
2337  fSelectedElectrons->clear();
2338 
2339 
2340 
2341 
2342  if(eleHandle.isValid()) {
2343 
2344  for( reco::GsfElectronCollection::const_iterator iter = eleHandle->begin(), iend = eleHandle->end(); iter != iend; ++iter )
2345  {
2346 
2347  edm::Handle< EcalRecHitCollection > pEBRecHits;
2348  iEvent.getByToken( recHitsEBToken, pEBRecHits );
2349 
2350  edm::Handle< EcalRecHitCollection > pEERecHits;
2351  iEvent.getByToken( recHitsEEToken, pEERecHits );
2352 
2353  if(pEBRecHits.isValid() && pEERecHits.isValid()) {
2354 
2355  EcalClusterLazyTools lazyTool(iEvent, iSetup, recHitsEBToken, recHitsEEToken);
2356  const reco::CaloCluster* bc = iter->superCluster()->seed().get(); // get the basic cluster
2357 
2358  float eleMaxOver3x3 = ( lazyTool.eMax(*bc) / lazyTool.e3x3(*bc) );
2359 
2360  if(eleMaxOver3x3 > eleMaxOver3x3_) continue;
2361 
2362  }
2363 
2364  // Only ecalDriven electrons
2365  if(! iter->ecalDriven() ) continue;
2366 
2367 
2368  // Barrel
2369  if(iter->isEB()) {
2370 
2371  if (
2372  iter->dr03TkSumPt() < dr03TkSumPtEB_ &&
2373  iter->dr04EcalRecHitSumEt() < dr04EcalRecHitSumEtEB_ &&
2374  iter->dr04HcalTowerSumEt() < dr04HcalTowerSumEtEB_ &&
2375  iter->hadronicOverEm() < hadronicOverEmEB_ &&
2376  fabs(iter->deltaPhiSuperClusterTrackAtVtx()) < deltaPhiSuperClusterTrackAtVtxEB_ &&
2377  fabs(iter->deltaEtaSuperClusterTrackAtVtx()) < deltaEtaSuperClusterTrackAtVtxEB_ &&
2378  iter->sigmaIetaIeta() < sigmaIetaIetaEB_ &&
2379  //spikes
2380  iter->sigmaIetaIeta() > sigmaIetaIetaSpikesEB_
2381  ) {
2382 
2383  fSelectedElectrons->push_back(*iter);
2384 
2385  }
2386 
2387  } // end if
2388 
2389  // EndCap
2390  else if(iter->isEE()) {
2391  if (
2392  iter->dr03TkSumPt() < dr03TkSumPtEC_ &&
2393  iter->dr04EcalRecHitSumEt() < dr04EcalRecHitSumEtEC_ &&
2394  iter->dr04HcalTowerSumEt() < dr04HcalTowerSumEtEC_ &&
2395  iter->hadronicOverEm() < hadronicOverEmEC_ &&
2396  fabs(iter->deltaPhiSuperClusterTrackAtVtx()) < deltaPhiSuperClusterTrackAtVtxEC_ &&
2397  fabs(iter->deltaEtaSuperClusterTrackAtVtx()) < deltaEtaSuperClusterTrackAtVtxEC_ &&
2398  iter->sigmaIetaIeta() < sigmaIetaIetaEC_ &&
2399  //spikes
2400  iter->sigmaIetaIeta() > sigmaIetaIetaSpikesEC_
2401  ) {
2402 
2403  fSelectedElectrons->push_back(*iter);
2404 
2405  }
2406 
2407  } // end else if
2408 
2409 
2410  } // end for
2411 
2412  edm::Handle<reco::GsfElectronCollection> localSelElectronsHandle(fSelectedElectrons,eleHandle.provenance());
2413  fSelElectronsHandle = localSelElectronsHandle;
2414 
2415  } // end if
2416 
2417 
2418 }
FourVectorHLTOffline::fSelElectronsHandle
edm::Handle< reco::GsfElectronCollection > fSelElectronsHandle
Definition: FourVectorHLTOffline.h:200
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
FourVectorHLTOffline::recHitsEBToken
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit > > recHitsEBToken
Definition: FourVectorHLTOffline.h:343
FourVectorHLTOffline::fSelectedElectrons
reco::GsfElectronCollection * fSelectedElectrons
Definition: FourVectorHLTOffline.h:199
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
reco::CaloCluster::seed
DetId seed() const
return DetId of seed
Definition: CaloCluster.h:200
FourVectorHLTOffline::recHitsEEToken
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit > > recHitsEEToken
Definition: FourVectorHLTOffline.h:344
edm::HandleBase::provenance
Provenance const * provenance() const
Definition: HandleBase.h:85
void FourVectorHLTOffline::selectJets ( const edm::Event &  iEvent,
const edm::Handle< reco::CaloJetCollection > &  jetHandle 
)
private

Definition at line 2452 of file FourVectorHLTOffline.cc.

References reco::helper::JetIDHelper::calculate(), emEnergyFractionJet_, reco::helper::JetIDHelper::fHPD(), fHPDJet_, fSelectedJets, fSelJetsHandle, edm::HandleBase::isValid(), jetID, n90Jet_, and edm::HandleBase::provenance().

Referenced by analyze().

2453 {
2454  // for every event, first clear vector of selected objects
2455  fSelectedJets->clear();
2456 
2457  if(jetHandle.isValid()) {
2458 
2459  for( reco::CaloJetCollection::const_iterator iter = jetHandle->begin(), iend = jetHandle->end(); iter != iend; ++iter )
2460  {
2461 
2462  jetID->calculate(iEvent, *iter);
2463  if (iter->emEnergyFraction() > emEnergyFractionJet_ &&
2464  jetID->fHPD() < fHPDJet_ &&
2465  iter->n90() >= n90Jet_
2466  ){
2467 
2468  fSelectedJets->push_back(*iter);
2469 
2470  }
2471 
2472  } // end for
2473 
2474  edm::Handle<reco::CaloJetCollection> localSelJetsHandle(fSelectedJets,jetHandle.provenance());
2475  fSelJetsHandle = localSelJetsHandle;
2476 
2477  } // end if
2478 
2479 
2480 }
FourVectorHLTOffline::jetID
reco::helper::JetIDHelper * jetID
Definition: FourVectorHLTOffline.h:171
reco::helper::JetIDHelper::fHPD
double fHPD() const
Definition: JetIDHelper.h:40
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
FourVectorHLTOffline::fSelJetsHandle
edm::Handle< reco::CaloJetCollection > fSelJetsHandle
Definition: FourVectorHLTOffline.h:206
FourVectorHLTOffline::fSelectedJets
reco::CaloJetCollection * fSelectedJets
Definition: FourVectorHLTOffline.h:205
reco::helper::JetIDHelper::calculate
void calculate(const edm::Event &event, const reco::CaloJet &jet, const int iDbg=0)
Definition: JetIDHelper.cc:98
edm::HandleBase::provenance
Provenance const * provenance() const
Definition: HandleBase.h:85
void FourVectorHLTOffline::selectMet ( const edm::Handle< reco::CaloMETCollection > &  metHandle)
private

Definition at line 2482 of file FourVectorHLTOffline.cc.

References fSelectedMet, fSelMetHandle, edm::HandleBase::isValid(), and edm::HandleBase::provenance().

Referenced by analyze().

2483 {
2484  // for every event, first clear vector of selected objects
2485  fSelectedMet->clear();
2486 
2487  if(metHandle.isValid()) {
2488 
2489  for( reco::CaloMETCollection::const_iterator iter = metHandle->begin(), iend = metHandle->end(); iter != iend; ++iter )
2490  {
2491 
2492  fSelectedMet->push_back(*iter);
2493 
2494  } // end for
2495 
2496  edm::Handle<reco::CaloMETCollection> localSelMetHandle(fSelectedMet,metHandle.provenance());
2497  fSelMetHandle = localSelMetHandle;
2498 
2499  } // end if
2500 
2501 
2502 }
FourVectorHLTOffline::fSelMetHandle
edm::Handle< reco::CaloMETCollection > fSelMetHandle
Definition: FourVectorHLTOffline.h:209
FourVectorHLTOffline::fSelectedMet
reco::CaloMETCollection * fSelectedMet
Definition: FourVectorHLTOffline.h:208
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
edm::HandleBase::provenance
Provenance const * provenance() const
Definition: HandleBase.h:85
void FourVectorHLTOffline::selectMuons ( const edm::Handle< reco::MuonCollection > &  muonHandle)
private

Definition at line 2308 of file FourVectorHLTOffline.cc.

References fSelectedMuons, fSelMuonsHandle, muon::GlobalMuonPromptTight, muon::isGoodMuon(), edm::HandleBase::isValid(), isVBTFMuon(), edm::HandleBase::provenance(), and muon::TrackerMuonArbitrated.

Referenced by analyze().

2309 {
2310  // for every event, first clear vector of selected objects
2311  fSelectedMuons->clear();
2312 
2313  if(muonHandle.isValid()) {
2314 
2315  for( reco::MuonCollection::const_iterator iter = muonHandle->begin(), iend = muonHandle->end(); iter != iend; ++iter )
2316  {
2317 
2318  if(isGoodMuon(*iter, muon::GlobalMuonPromptTight) &&
2319  isGoodMuon(*iter, muon::TrackerMuonArbitrated))
2320  {
2321  if(isVBTFMuon(*iter)) fSelectedMuons->push_back(*iter);
2322  }
2323  } // end for
2324 
2325  edm::Handle<reco::MuonCollection> localSelMuonsHandle(fSelectedMuons,muonHandle.provenance());
2326  fSelMuonsHandle = localSelMuonsHandle;
2327 
2328  } // end if
2329 
2330 
2331 }
FourVectorHLTOffline::fSelMuonsHandle
edm::Handle< reco::MuonCollection > fSelMuonsHandle
Definition: FourVectorHLTOffline.h:197
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
FourVectorHLTOffline::isVBTFMuon
bool isVBTFMuon(const reco::Muon &muon)
Definition: FourVectorHLTOffline.cc:2588
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:567
FourVectorHLTOffline::fSelectedMuons
reco::MuonCollection * fSelectedMuons
Definition: FourVectorHLTOffline.h:196
edm::HandleBase::provenance
Provenance const * provenance() const
Definition: HandleBase.h:85
void FourVectorHLTOffline::selectPhotons ( const edm::Handle< reco::PhotonCollection > &  phoHandle)
private

Definition at line 2420 of file FourVectorHLTOffline.cc.

References fSelectedPhotons, fSelPhotonsHandle, edm::HandleBase::isValid(), and edm::HandleBase::provenance().

Referenced by analyze().

2421 {
2422  // for every event, first clear vector of selected objects
2423  fSelectedPhotons->clear();
2424 
2425  if(phoHandle.isValid()) {
2426 
2427  for( reco::PhotonCollection::const_iterator iter = phoHandle->begin(), iend = phoHandle->end(); iter != iend; ++iter )
2428  {
2429 
2430  if(
2431 
2432  //spikes
2433  iter->sigmaIetaIeta() > 0.002 &&
2434  iter->maxEnergyXtal() / iter->e3x3() < 0.9
2435 
2436  ) {
2437 
2438  fSelectedPhotons->push_back(*iter);
2439 
2440  } // end if
2441 
2442  } // end for
2443 
2444  edm::Handle<reco::PhotonCollection> localSelPhotonsHandle(fSelectedPhotons,phoHandle.provenance());
2445  fSelPhotonsHandle = localSelPhotonsHandle;
2446 
2447  } // end if
2448 
2449 
2450 }
FourVectorHLTOffline::fSelPhotonsHandle
edm::Handle< reco::PhotonCollection > fSelPhotonsHandle
Definition: FourVectorHLTOffline.h:203
FourVectorHLTOffline::fSelectedPhotons
reco::PhotonCollection * fSelectedPhotons
Definition: FourVectorHLTOffline.h:202
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
edm::HandleBase::provenance
Provenance const * provenance() const
Definition: HandleBase.h:85
void FourVectorHLTOffline::selectTaus ( const edm::Event &  iEvent)
private

Definition at line 2505 of file FourVectorHLTOffline.cc.

References fSelectedTaus, fSelTausHandle, edm::Event::getByToken(), hpsPFTauProdToken, i, edm::HandleBase::isValid(), edm::HandleBase::provenance(), tauDscrmtr1Token, tauDscrmtr2Token, and tauDscrmtr3Token.

Referenced by analyze().

2506 {
2507  // for every event, first clear vector of selected objects
2508  fSelectedTaus->clear();
2509 
2510  //first read the tau collection
2511  edm::Handle<reco::PFTauCollection> tauHandle;
2512  iEvent.getByToken(hpsPFTauProdToken,tauHandle);
2513 
2514  //Now access a discriminator and see if it passed the tag
2515  edm::Handle<reco::PFTauDiscriminator> dscrmt1H;
2516  iEvent.getByToken(tauDscrmtr1Token,dscrmt1H);
2517  edm::Handle<reco::PFTauDiscriminator> dscrmt2H;
2518  iEvent.getByToken(tauDscrmtr2Token,dscrmt2H);
2519  edm::Handle<reco::PFTauDiscriminator> dscrmt3H;
2520  iEvent.getByToken(tauDscrmtr3Token,dscrmt3H);
2521 
2522  if(tauHandle.isValid() && dscrmt1H.isValid() && dscrmt2H.isValid() && dscrmt3H.isValid()) {
2523 
2524  for(unsigned int i=0;i<tauHandle->size();++i) {
2525 
2526  //create a ref to the PF Tau
2527  reco::PFTauRef pfTauRef(tauHandle,i);
2528 
2529  float outputDiscmnt1 = (*dscrmt1H)[pfTauRef]; // this should be >0.5 to pass
2530  float outputDiscmnt2 = (*dscrmt2H)[pfTauRef]; // this should be >0.5 to pass
2531  float outputDiscmnt3 = (*dscrmt3H)[pfTauRef]; // this should be >0.5 to pass
2532 
2533  if(outputDiscmnt1>0.5 && outputDiscmnt2>0.5 && outputDiscmnt3 >0.5) {
2534 
2535  fSelectedTaus->push_back((*tauHandle)[i]);
2536 
2537  }
2538 
2539  } // end for
2540 
2541 
2542  edm::Handle<reco::PFTauCollection> localSelTauHandle(fSelectedTaus,tauHandle.provenance());
2543  fSelTausHandle = localSelTauHandle;
2544 
2545  } // end if
2546 
2547 }
i
int i
Definition: DBlmapReader.cc:9
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
FourVectorHLTOffline::fSelectedTaus
reco::PFTauCollection * fSelectedTaus
Definition: FourVectorHLTOffline.h:213
FourVectorHLTOffline::tauDscrmtr1Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr1Token
Definition: FourVectorHLTOffline.h:346
FourVectorHLTOffline::fSelTausHandle
edm::Handle< reco::PFTauCollection > fSelTausHandle
Definition: FourVectorHLTOffline.h:214
FourVectorHLTOffline::tauDscrmtr2Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr2Token
Definition: FourVectorHLTOffline.h:347
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
FourVectorHLTOffline::tauDscrmtr3Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr3Token
Definition: FourVectorHLTOffline.h:348
FourVectorHLTOffline::hpsPFTauProdToken
edm::EDGetTokenT< std::vector< reco::PFTau > > hpsPFTauProdToken
Definition: FourVectorHLTOffline.h:345
edm::HandleBase::provenance
Provenance const * provenance() const
Definition: HandleBase.h:85
void FourVectorHLTOffline::setupHltBxPlots ( )
private

Definition at line 1711 of file FourVectorHLTOffline.cc.

References DQMStore::book2D(), dbe_, MonitorElement::getTH2F(), hltPathsDiagonal_, i, ME_HLT_BX, Nbx_, pathsSummaryFolder_, MonitorElement::setAxisTitle(), and DQMStore::setCurrentFolder().

1712 {
1713 
1714  //pathsSummaryFolder_ = TString("HLT/FourVector/PathsSummary/");
1715  //dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());
1716  dbe_->setCurrentFolder(pathsSummaryFolder_);
1717 
1718  // setup HLT bx plot
1719  unsigned int npaths = hltPathsDiagonal_.size();
1720 
1721  ME_HLT_BX = dbe_->book2D("HLT_bx",
1722  "HLT counts vs Event bx",
1723  Nbx_+1, -0.5, Nbx_+1-0.5, npaths, -0.5, npaths-0.5);
1724  /*
1725  ME_HLT_CUSTOM_BX = dbe_->book2D("HLT_Custom_bx",
1726  "HLT counts vs Event bx",
1727  Nbx_+1, -0.5, Nbx_+1-0.5, npaths, -0.5, npaths-0.5);
1728  */
1729  ME_HLT_BX->setAxisTitle("Bunch Crossing");
1730  //ME_HLT_CUSTOM_BX->setAxisTitle("Bunch Crossing");
1731 
1732 
1733  // Set up bin labels on Y axis continuing to cover all npaths
1734  for(unsigned int i = 0; i < npaths; i++){
1735 
1736  if (ME_HLT_BX)
1737  ME_HLT_BX->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());
1738  //ME_HLT_CUSTOM_BX->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());
1739 
1740  }
1741 
1742 
1743 }
i
int i
Definition: DBlmapReader.cc:9
FourVectorHLTOffline::hltPathsDiagonal_
PathInfoCollection hltPathsDiagonal_
Definition: FourVectorHLTOffline.h:722
FourVectorHLTOffline::ME_HLT_BX
MonitorElement * ME_HLT_BX
Definition: FourVectorHLTOffline.h:179
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1522
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:1056
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:928
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:639
void FourVectorHLTOffline::setupHltLsPlots ( )
private

Definition at line 1745 of file FourVectorHLTOffline.cc.

References DQMStore::book2D(), dbe_, MonitorElement::getTH2F(), hltPathsDiagonal_, i, ME_HLTAll_LS, nLS_, pathsSummaryHLTPathsPerLSFolder_, MonitorElement::setAxisTitle(), and DQMStore::setCurrentFolder().

1746 {
1747 
1748  unsigned int npaths = hltPathsDiagonal_.size();
1749 
1750  //pathsSummaryHLTPathsPerLSFolder_ = TString("HLT/FourVector/PathsSummary/HLT LS/");
1751  //dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_.c_str());
1752  dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_);
1753 
1754  ME_HLTAll_LS = dbe_->book2D("All_count_LS",
1755  "All paths per LS ",
1756  nLS_, 0, nLS_, npaths+1, -0.5, npaths+1-0.5);
1757  ME_HLTAll_LS->setAxisTitle("Luminosity Section");
1758 
1759  // Set up bin labels on Y axis continuing to cover all npaths
1760  for(unsigned int i = 0; i < npaths; i++){
1761  if (ME_HLTAll_LS)
1762  ME_HLTAll_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());
1763 
1764  }
1765 
1766  unsigned int i = npaths;
1767 
1768  if (ME_HLTAll_LS)
1769  ME_HLTAll_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, "HLT_Any");
1770 
1771 
1772 }
i
int i
Definition: DBlmapReader.cc:9
FourVectorHLTOffline::pathsSummaryHLTPathsPerLSFolder_
std::string pathsSummaryHLTPathsPerLSFolder_
Definition: FourVectorHLTOffline.h:189
FourVectorHLTOffline::hltPathsDiagonal_
PathInfoCollection hltPathsDiagonal_
Definition: FourVectorHLTOffline.h:722
FourVectorHLTOffline::ME_HLTAll_LS
MonitorElement * ME_HLTAll_LS
Definition: FourVectorHLTOffline.h:178
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1522
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:1056
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:928
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:639
void FourVectorHLTOffline::setupHltMatrix ( const std::string &  label,
std::vector< std::string > &  paths 
)
private

Definition at line 1491 of file FourVectorHLTOffline.cc.

References DQMStore::book1D(), DQMStore::book2D(), dbe_, MonitorElement::getTH1F(), MonitorElement::getTH2F(), i, nLS_, pathsSummaryFolder_, pathsSummaryHLTCorrelationsFolder_, pathsSummaryHLTPathsPerLSFolder_, MonitorElement::setAxisTitle(), and DQMStore::setCurrentFolder().

Referenced by beginRun().

1491  {
1492 
1493  //string groupLabelAny = "HLT_"+label+"_Any";
1494  //paths.push_back(groupLabelAny.c_str());
1495  paths.push_back("HLT_"+label+"_L1_Any");
1496  paths.push_back("HLT_"+label+"_Any");
1497  paths.push_back("HLT_Any");
1498 
1499  string h_name;
1500  string h_title;
1501 
1502  dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());
1503 
1504  MonitorElement* ME = 0;
1505  MonitorElement* ME_Any = 0;
1506  MonitorElement* ME_Normalized = 0;
1507  MonitorElement* ME_Normalized_Any = 0;
1508 
1509  if (label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor") {
1510  h_name= "HLT_"+label+"_PassPass";
1511  h_title = "HLT_"+label+"_PassPass (x=Pass, y=Pass)";
1512  ME = dbe_->book2D(h_name.c_str(), h_title.c_str(),
1513  paths.size(), -0.5, paths.size()-0.5, paths.size(), -0.5, paths.size()-0.5);
1514 
1515  h_name= "HLT_"+label+"_Pass_Any";
1516  h_title = "HLT_"+label+"_Pass (x=Pass, Any=Pass) normalized to HLT_Any Pass";
1517  ME_Any = dbe_->book1D(h_name.c_str(), h_title.c_str(),
1518  paths.size(), -0.5, paths.size()-0.5);
1519 
1520  dbe_->setCurrentFolder(pathsSummaryHLTCorrelationsFolder_.c_str());
1521  h_name= "HLT_"+label+"_PassPass_Normalized";
1522  h_title = "HLT_"+label+"_PassPass (x=Pass, y=Pass) normalized to xBin=Pass";
1523  ME_Normalized = dbe_->book2D(h_name.c_str(), h_title.c_str(),
1524  paths.size(), -0.5, paths.size()-0.5, paths.size(), -0.5, paths.size()-0.5);
1525  h_name= "HLT_"+label+"_Pass_Normalized_Any";
1526  h_title = "HLT_"+label+"_Pass (x=Pass, Any=Pass) normalized to HLT_Any Pass";
1527  ME_Normalized_Any = dbe_->book1D(h_name.c_str(), h_title.c_str(),
1528  paths.size(), -0.5, paths.size()-0.5);
1529  }
1530 
1531  if (label != "All" && label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor")
1532  {
1533  dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_ + label);
1534  h_name= "HLT_"+label+"_Total_LS";
1535  h_title = label+" HLT paths total count combined per LS ";
1536  MonitorElement* ME_Total_LS = dbe_->book1D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_);
1537  ME_Total_LS->setAxisTitle("LS");
1538 
1539 // for(std::vector<std::string>::iterator i = paths.begin(), e=paths.end(); i!=e; ++i)
1540 // {
1541 // h_name= "HLT_"+removeVersions(*i)+"_LS";
1542 // h_title = removeVersions(*i) + " inside " + label + " HLT paths count per LS ";
1543 // MonitorElement* ME_Group_LS = dbe_->book1D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_);
1544 // ME_Group_LS->setAxisTitle("LS");
1545 // /// add this path to the vector of 2D LS paths
1546 // v_ME_HLTAll_LS.push_back(ME_Group_LS);
1547 // }
1548 
1549  }
1550 
1551 
1552 // dbe_->setCurrentFolder(pathsSummaryHLTPathsPerBXFolder_.c_str());
1553 // h_name= "HLT_"+label+"_BX_LS";
1554 // h_title = label+" HLT paths total count combined per BX ";
1555 // MonitorElement* ME_Total_BX = dbe_->book2D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_, 5, -2.5, 2.5);
1556 // ME_Total_BX->setAxisTitle("LS",1);
1557 // v_ME_Total_BX.push_back(ME_Total_BX);
1558 
1559 // h_name= "HLT_"+label+"_BX_LS_Norm";
1560 // h_title = label+" HLT paths total count combined per BX Normalized to LS";
1561 // MonitorElement* ME_Total_BX_Norm = dbe_->book2D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_, 5, -2.5, 2.5);
1562 // ME_Total_BX_Norm->setAxisTitle("LS",1);
1563 // v_ME_Total_BX_Norm.push_back(ME_Total_BX_Norm);
1564 
1565 // bjk: These are OK
1566  if (label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor") {
1567  for(unsigned int i = 0; i < paths.size(); i++){
1568 
1569  if (ME) {
1570  ME->getTH2F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1571  ME->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1572  }
1573  // ME_Group_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1574  if (ME_Normalized){
1575  ME_Normalized->getTH2F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1576  ME_Normalized->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1577  }
1578  if (ME_Normalized_Any)
1579  ME_Normalized_Any->getTH1F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1580 
1581  if (ME_Any)
1582  ME_Any->getTH1F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1583  }
1584  }
1585 
1586 }
i
int i
Definition: DBlmapReader.cc:9
EgammaValidation_cff.paths
tuple paths
Definition: EgammaValidation_cff.py:18
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:928
FourVectorHLTOffline::pathsSummaryHLTPathsPerLSFolder_
std::string pathsSummaryHLTPathsPerLSFolder_
Definition: FourVectorHLTOffline.h:189
ME
Definition: ME.h:11
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1498
FourVectorHLTOffline::pathsSummaryHLTCorrelationsFolder_
std::string pathsSummaryHLTCorrelationsFolder_
Definition: FourVectorHLTOffline.h:186
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1522
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:1056
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:928
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:639

Member Data Documentation

edm::EDGetTokenT<reco::BeamSpot> FourVectorHLTOffline::beamSpotToken
private

Definition at line 333 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::bjetDRMatch_
private

Definition at line 252 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::bjetEtaMax_
private

Definition at line 250 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::bjetEtMin_
private

Definition at line 251 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::bjetL1DRMatch_
private

Definition at line 253 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

int FourVectorHLTOffline::currentRun_
private

Definition at line 224 of file FourVectorHLTOffline.h.

std::vector<std::pair<std::string, std::string> > FourVectorHLTOffline::custompathnamepairs_
private

Definition at line 312 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

DQMStore* FourVectorHLTOffline::dbe_
private

Definition at line 164 of file FourVectorHLTOffline.h.

Referenced by beginRun(), countHLTGroupHitsEndLumiBlock(), countHLTGroupL1HitsEndLumiBlock(), countHLTPathHitsEndLumiBlock(), fillHltMatrix(), FourVectorHLTOffline(), setupHltBxPlots(), setupHltLsPlots(), and setupHltMatrix().

float FourVectorHLTOffline::deltaEtaSuperClusterTrackAtVtxEB_
private

Definition at line 291 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::deltaEtaSuperClusterTrackAtVtxEC_
private

Definition at line 301 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::deltaPhiSuperClusterTrackAtVtxEB_
private

Definition at line 290 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::deltaPhiSuperClusterTrackAtVtxEC_
private

Definition at line 300 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

std::string FourVectorHLTOffline::dirname_
private

Definition at line 324 of file FourVectorHLTOffline.h.

Referenced by beginJob(), beginRun(), and FourVectorHLTOffline().

bool FourVectorHLTOffline::doCombineRuns_
private

Definition at line 223 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

float FourVectorHLTOffline::dr03TkSumPtEB_
private

Definition at line 286 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::dr03TkSumPtEC_
private

Definition at line 296 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::dr04EcalRecHitSumEtEB_
private

Definition at line 287 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::dr04EcalRecHitSumEtEC_
private

Definition at line 297 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::dr04HcalTowerSumEtEB_
private

Definition at line 288 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::dr04HcalTowerSumEtEC_
private

Definition at line 298 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

double FourVectorHLTOffline::dRMax_
private

Definition at line 232 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::dxyCut_
private

Definition at line 274 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and isVBTFMuon().

double FourVectorHLTOffline::electronDRMatch_
private

Definition at line 236 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::electronEtaMax_
private

Definition at line 234 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::electronEtMin_
private

Definition at line 235 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::electronL1DRMatch_
private

Definition at line 237 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

float FourVectorHLTOffline::eleMaxOver3x3_
private

Definition at line 284 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::emEnergyFractionJet_
private

Definition at line 308 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectJets().

edm::Handle<reco::BeamSpot> FourVectorHLTOffline::fBeamSpotHandle

Definition at line 123 of file FourVectorHLTOffline.h.

Referenced by analyze(), and isVBTFMuon().

std::string FourVectorHLTOffline::fCustomBXPath
private

Definition at line 192 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

std::vector<std::pair<std::string, float> > FourVectorHLTOffline::fGroupL1TempCountPair
private

Definition at line 319 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and countHLTGroupL1HitsEndLumiBlock().

std::vector<std::string> FourVectorHLTOffline::fGroupName
private

Definition at line 194 of file FourVectorHLTOffline.h.

Referenced by beginRun().

std::vector<std::pair<std::string, std::vector<std::string> > > FourVectorHLTOffline::fGroupNamePathsPair
private

Definition at line 320 of file FourVectorHLTOffline.h.

Referenced by beginRun(), countHLTGroupBXHitsEndLumiBlock(), countHLTGroupHitsEndLumiBlock(), countHLTGroupL1HitsEndLumiBlock(), and fillHltMatrix().

std::vector<std::pair<std::string, float> > FourVectorHLTOffline::fGroupTempCountPair
private

Definition at line 318 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and countHLTGroupHitsEndLumiBlock().

float FourVectorHLTOffline::fHPDJet_
private

Definition at line 309 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectJets().

bool FourVectorHLTOffline::fIsSetup
private

Definition at line 166 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

bool FourVectorHLTOffline::fLumiFlag
private

Definition at line 165 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

std::vector<std::pair<std::string, std::vector<int> > > FourVectorHLTOffline::fPathBxTempCountPair
private

Definition at line 317 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and countHLTGroupBXHitsEndLumiBlock().

std::vector<std::pair<std::string, float> > FourVectorHLTOffline::fPathTempCountPair
private

Definition at line 316 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and countHLTPathHitsEndLumiBlock().

reco::GsfElectronCollection* FourVectorHLTOffline::fSelectedElectrons
private

Definition at line 199 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), selectElectrons(), and ~FourVectorHLTOffline().

reco::CaloJetCollection* FourVectorHLTOffline::fSelectedJets
private

Definition at line 205 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), selectJets(), and ~FourVectorHLTOffline().

reco::CaloMETCollection* FourVectorHLTOffline::fSelectedMet
private

Definition at line 208 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), selectMet(), and ~FourVectorHLTOffline().

reco::MuonCollection* FourVectorHLTOffline::fSelectedMuons
private

Definition at line 196 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), selectMuons(), and ~FourVectorHLTOffline().

reco::PhotonCollection* FourVectorHLTOffline::fSelectedPhotons
private

Definition at line 202 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), selectPhotons(), and ~FourVectorHLTOffline().

reco::PFTauCollection* FourVectorHLTOffline::fSelectedTaus
private

Definition at line 213 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), selectTaus(), and ~FourVectorHLTOffline().

edm::Handle<reco::GsfElectronCollection> FourVectorHLTOffline::fSelElectronsHandle
private

Definition at line 200 of file FourVectorHLTOffline.h.

Referenced by analyze(), and selectElectrons().

edm::Handle<reco::CaloJetCollection> FourVectorHLTOffline::fSelJetsHandle
private

Definition at line 206 of file FourVectorHLTOffline.h.

Referenced by analyze(), and selectJets().

edm::Handle<reco::CaloMETCollection> FourVectorHLTOffline::fSelMetHandle
private

Definition at line 209 of file FourVectorHLTOffline.h.

Referenced by analyze(), and selectMet().

edm::Handle<reco::MuonCollection> FourVectorHLTOffline::fSelMuonsHandle
private

Definition at line 197 of file FourVectorHLTOffline.h.

Referenced by analyze(), and selectMuons().

edm::Handle<reco::PhotonCollection> FourVectorHLTOffline::fSelPhotonsHandle
private

Definition at line 203 of file FourVectorHLTOffline.h.

Referenced by selectPhotons().

edm::Handle<reco::PFTauCollection> FourVectorHLTOffline::fSelTausHandle
private

Definition at line 214 of file FourVectorHLTOffline.h.

Referenced by analyze(), and selectTaus().

edm::Handle<trigger::TriggerEvent> FourVectorHLTOffline::fTriggerObj

Definition at line 121 of file FourVectorHLTOffline.h.

Referenced by analyze(), objMonData< T >::fillOnL1Match(), objMonData< T >::fillOnlineMatch(), objMonData< T >::matchOnlineL1(), objMonData< T >::monitorL1(), and objMonData< T >::monitorOnline().

edm::Handle<edm::TriggerResults> FourVectorHLTOffline::fTriggerResults

Definition at line 122 of file FourVectorHLTOffline.h.

Referenced by analyze(), fillHltMatrix(), hasHLTPassed(), and hasL1Passed().

edm::EDGetTokenT<reco::GsfElectronCollection> FourVectorHLTOffline::gsfElectronToken
private

Definition at line 335 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

float FourVectorHLTOffline::hadronicOverEmEB_
private

Definition at line 289 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::hadronicOverEmEC_
private

Definition at line 299 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

HLTConfigProvider FourVectorHLTOffline::hltConfig_
private

Definition at line 355 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and getL1ConditionModuleName().

PathInfoCollection FourVectorHLTOffline::hltPaths_

Definition at line 720 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

PathInfoCollection FourVectorHLTOffline::hltPathsDiagonal_

Definition at line 722 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), hasL1Passed(), setupHltBxPlots(), and setupHltLsPlots().

edm::EDGetTokenT<std::vector<reco::PFTau> > FourVectorHLTOffline::hpsPFTauProdToken
private

Definition at line 345 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectTaus().

double FourVectorHLTOffline::htDRMatch_
private

Definition at line 268 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

double FourVectorHLTOffline::htEtaMax_
private

Definition at line 266 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

double FourVectorHLTOffline::htL1DRMatch_
private

Definition at line 269 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

double FourVectorHLTOffline::htMin_
private

Definition at line 267 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

edm::EDGetTokenT<reco::CaloJetCollection> FourVectorHLTOffline::iC5calojetToken
private

Definition at line 337 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

bool FourVectorHLTOffline::isAlsoTrackerMuon_
private

Definition at line 279 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

double FourVectorHLTOffline::jetDRMatch_
private

Definition at line 248 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::jetEtaMax_
private

Definition at line 246 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::jetEtMin_
private

Definition at line 247 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

reco::helper::JetIDHelper* FourVectorHLTOffline::jetID
private

Definition at line 171 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectJets().

double FourVectorHLTOffline::jetL1DRMatch_
private

Definition at line 249 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

edm::EDGetTokenT<reco::JetTagCollection> FourVectorHLTOffline::jlipBtagToken
private

Definition at line 338 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::LSsize_
private

Definition at line 217 of file FourVectorHLTOffline.h.

Referenced by countHLTGroupHitsEndLumiBlock(), countHLTGroupL1HitsEndLumiBlock(), countHLTPathHitsEndLumiBlock(), and FourVectorHLTOffline().

MonitorElement* FourVectorHLTOffline::ME_HLT_BX
private

Definition at line 179 of file FourVectorHLTOffline.h.

Referenced by countHLTGroupBXHitsEndLumiBlock(), FourVectorHLTOffline(), and setupHltBxPlots().

MonitorElement* FourVectorHLTOffline::ME_HLT_CUSTOM_BX
private

Definition at line 180 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

MonitorElement* FourVectorHLTOffline::ME_HLTAll_LS
private

Definition at line 178 of file FourVectorHLTOffline.h.

Referenced by countHLTPathHitsEndLumiBlock(), FourVectorHLTOffline(), and setupHltLsPlots().

double FourVectorHLTOffline::metDRMatch_
private

Definition at line 264 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::metEtaMax_
private

Definition at line 262 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::metL1DRMatch_
private

Definition at line 265 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::metMin_
private

Definition at line 263 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

edm::EDGetTokenT<reco::CaloMETCollection> FourVectorHLTOffline::METToken
private

Definition at line 340 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

bool FourVectorHLTOffline::monitorDaemon_
private

Definition at line 327 of file FourVectorHLTOffline.h.

double FourVectorHLTOffline::muonDRMatch_
private

Definition at line 240 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::muonEtaMax_
private

Definition at line 238 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::muonEtMin_
private

Definition at line 239 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

int FourVectorHLTOffline::muonHitsCut_
private

Definition at line 278 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and isVBTFMuon().

double FourVectorHLTOffline::muonL1DRMatch_
private

Definition at line 241 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

std::string FourVectorHLTOffline::muonRecoCollectionName_
private

Definition at line 326 of file FourVectorHLTOffline.h.

edm::EDGetTokenT<reco::MuonCollection> FourVectorHLTOffline::muonRecoCollectionToken
private

Definition at line 334 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

int FourVectorHLTOffline::n90Jet_
private

Definition at line 310 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectJets().

unsigned int FourVectorHLTOffline::nBins2D_
private

Definition at line 228 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

unsigned int FourVectorHLTOffline::nBins_
private

Definition at line 226 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

unsigned int FourVectorHLTOffline::nBinsDR_
private

Definition at line 227 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

unsigned int FourVectorHLTOffline::nBinsOneOverEt_
private

Definition at line 229 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

unsigned int FourVectorHLTOffline::Nbx_
private

Definition at line 220 of file FourVectorHLTOffline.h.

Referenced by countHLTGroupBXHitsEndLumiBlock(), FourVectorHLTOffline(), and setupHltBxPlots().

int FourVectorHLTOffline::nev_
private

Definition at line 163 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginJob(), and endJob().

unsigned int FourVectorHLTOffline::nLS_
private

Definition at line 216 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), setupHltLsPlots(), and setupHltMatrix().

int FourVectorHLTOffline::nMatchesCut_
private

Definition at line 280 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and isVBTFMuon().

double FourVectorHLTOffline::normalizedChi2Cut_
private

Definition at line 275 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and isVBTFMuon().

std::string FourVectorHLTOffline::pathsIndividualHLTPathsPerLSFolder_
private

Definition at line 190 of file FourVectorHLTOffline.h.

std::string FourVectorHLTOffline::pathsSummaryFilterCountsFolder_
private

Definition at line 188 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

std::string FourVectorHLTOffline::pathsSummaryFilterEfficiencyFolder_
private

Definition at line 187 of file FourVectorHLTOffline.h.

std::string FourVectorHLTOffline::pathsSummaryFolder_
private

Definition at line 185 of file FourVectorHLTOffline.h.

Referenced by beginRun(), FourVectorHLTOffline(), setupHltBxPlots(), and setupHltMatrix().

std::string FourVectorHLTOffline::pathsSummaryHLTCorrelationsFolder_
private

Definition at line 186 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and setupHltMatrix().

std::string FourVectorHLTOffline::pathsSummaryHLTPathsPerBXFolder_
private

Definition at line 191 of file FourVectorHLTOffline.h.

std::string FourVectorHLTOffline::pathsSummaryHLTPathsPerLSFolder_
private

Definition at line 189 of file FourVectorHLTOffline.h.

Referenced by countHLTGroupHitsEndLumiBlock(), countHLTGroupL1HitsEndLumiBlock(), FourVectorHLTOffline(), setupHltLsPlots(), and setupHltMatrix().

double FourVectorHLTOffline::photonDRMatch_
private

Definition at line 256 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::photonEtaMax_
private

Definition at line 254 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::photonEtMin_
private

Definition at line 255 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::photonL1DRMatch_
private

Definition at line 257 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

edm::EDGetTokenT<reco::PhotonCollection> FourVectorHLTOffline::photonToken
private

Definition at line 341 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

int FourVectorHLTOffline::pixelHitsCut_
private

Definition at line 277 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and isVBTFMuon().

edm::EDGetTokenT<reco::TrackCollection> FourVectorHLTOffline::pixelTrackToken
private

Definition at line 342 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

bool FourVectorHLTOffline::plotAll_
private

Definition at line 222 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

std::string FourVectorHLTOffline::processname_
private

Definition at line 325 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::ptMax_
private

Definition at line 231 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

double FourVectorHLTOffline::ptMin_
private

Definition at line 230 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

edm::InputTag FourVectorHLTOffline::recHitsEBTag_
private

Definition at line 352 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

edm::EDGetTokenT<edm::SortedCollection<EcalRecHit> > FourVectorHLTOffline::recHitsEBToken
private

Definition at line 343 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

edm::InputTag FourVectorHLTOffline::recHitsEETag_
private

Definition at line 353 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

edm::EDGetTokenT<edm::SortedCollection<EcalRecHit> > FourVectorHLTOffline::recHitsEEToken
private

Definition at line 344 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

unsigned int FourVectorHLTOffline::referenceBX_
private

Definition at line 219 of file FourVectorHLTOffline.h.

Referenced by countHLTGroupBXHitsEndLumiBlock(), and FourVectorHLTOffline().

MonitorElement* FourVectorHLTOffline::scalersSelect
private

Definition at line 357 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

float FourVectorHLTOffline::sigmaIetaIetaEB_
private

Definition at line 292 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::sigmaIetaIetaEC_
private

Definition at line 302 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::sigmaIetaIetaSpikesEB_
private

Definition at line 294 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

float FourVectorHLTOffline::sigmaIetaIetaSpikesEC_
private

Definition at line 304 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectElectrons().

edm::EDGetTokenT<reco::JetTagCollection> FourVectorHLTOffline::softMuBtagToken
private

Definition at line 339 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

std::vector<std::string> FourVectorHLTOffline::specialPaths_
private

Definition at line 322 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

double FourVectorHLTOffline::sumEtMin_
private

Definition at line 270 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

double FourVectorHLTOffline::tauDRMatch_
private

Definition at line 244 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

edm::EDGetTokenT<reco::PFTauDiscriminator> FourVectorHLTOffline::tauDscrmtr1Token
private

Definition at line 346 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectTaus().

edm::EDGetTokenT<reco::PFTauDiscriminator> FourVectorHLTOffline::tauDscrmtr2Token
private

Definition at line 347 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectTaus().

edm::EDGetTokenT<reco::PFTauDiscriminator> FourVectorHLTOffline::tauDscrmtr3Token
private

Definition at line 348 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and selectTaus().

std::string FourVectorHLTOffline::tauDscrmtrLabel1_
private

Definition at line 174 of file FourVectorHLTOffline.h.

std::string FourVectorHLTOffline::tauDscrmtrLabel2_
private

Definition at line 175 of file FourVectorHLTOffline.h.

std::string FourVectorHLTOffline::tauDscrmtrLabel3_
private

Definition at line 176 of file FourVectorHLTOffline.h.

double FourVectorHLTOffline::tauEtaMax_
private

Definition at line 242 of file FourVectorHLTOffline.h.

Referenced by analyze(), beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::tauEtMin_
private

Definition at line 243 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::tauL1DRMatch_
private

Definition at line 245 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

edm::EDGetTokenT<std::vector<reco::PFTau> > FourVectorHLTOffline::tauProdToken
private

Definition at line 336 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

int FourVectorHLTOffline::theHLTOutputType
private

Definition at line 328 of file FourVectorHLTOffline.h.

double FourVectorHLTOffline::thresholdFactor_
private

Definition at line 218 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

double FourVectorHLTOffline::trackDRMatch_
private

Definition at line 260 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

int FourVectorHLTOffline::trackerHitsCut_
private

Definition at line 276 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline(), and isVBTFMuon().

double FourVectorHLTOffline::trackEtaMax_
private

Definition at line 258 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

double FourVectorHLTOffline::trackEtMin_
private

Definition at line 259 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

double FourVectorHLTOffline::trackL1DRMatch_
private

Definition at line 261 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

std::vector<std::vector <uint> > FourVectorHLTOffline::triggerFilterIndices_
private

Definition at line 315 of file FourVectorHLTOffline.h.

std::vector<std::vector <std::string> > FourVectorHLTOffline::triggerFilters_
private

Definition at line 314 of file FourVectorHLTOffline.h.

edm::EDGetTokenT<edm::TriggerResults> FourVectorHLTOffline::triggerResultsFUToken
private

Definition at line 330 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

edm::InputTag FourVectorHLTOffline::triggerResultsLabel_
private

Definition at line 351 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

edm::EDGetTokenT<edm::TriggerResults> FourVectorHLTOffline::triggerResultsToken
private

Definition at line 329 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

edm::EDGetTokenT<trigger::TriggerEvent> FourVectorHLTOffline::triggerSummaryFUToken
private

Definition at line 332 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

edm::InputTag FourVectorHLTOffline::triggerSummaryLabel_
private

Definition at line 350 of file FourVectorHLTOffline.h.

Referenced by FourVectorHLTOffline().

edm::EDGetTokenT<trigger::TriggerEvent> FourVectorHLTOffline::triggerSummaryToken
private

Definition at line 331 of file FourVectorHLTOffline.h.

Referenced by analyze(), and FourVectorHLTOffline().

bool FourVectorHLTOffline::useUM
private

Definition at line 168 of file FourVectorHLTOffline.h.

Referenced by beginRun(), and FourVectorHLTOffline().

std::vector<MonitorElement*> FourVectorHLTOffline::v_ME_HLTAll_LS
private

Definition at line 181 of file FourVectorHLTOffline.h.

std::vector<MonitorElement*> FourVectorHLTOffline::v_ME_Total_BX
private

Definition at line 182 of file FourVectorHLTOffline.h.

Referenced by countHLTGroupBXHitsEndLumiBlock().

std::vector<MonitorElement*> FourVectorHLTOffline::v_ME_Total_BX_Norm
private

Definition at line 183 of file FourVectorHLTOffline.h.

Referenced by countHLTGroupBXHitsEndLumiBlock().

Generated for CMSSW Reference Manual by doxygen 1.8.5