FourVectorHLTOffline Class Reference

#include <FourVectorHLTOffline.h>

Inheritance diagram for FourVectorHLTOffline:

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, hlt_relval-layouts::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.

                                                                        : currentRun_(-99)
{

  LogDebug("FourVectorHLTOffline") << "constructor...." ;

  useUM = false;
  fIsSetup = false;
  fSelectedMuons = new reco::MuonCollection;
  fSelectedElectrons = new reco::GsfElectronCollection;
  fSelectedPhotons = new reco::PhotonCollection;
  fSelectedJets = new reco::CaloJetCollection;
  fSelectedMet = new reco::CaloMETCollection;
  //fSelectedTaus = new reco::CaloTauCollection;
  fSelectedTaus = new reco::PFTauCollection;

  dbe_ = Service < DQMStore > ().operator->();
  if ( ! dbe_ ) {
    LogInfo("FourVectorHLTOffline") << "unabel to get DQMStore service?";
  }
  if (iConfig.getUntrackedParameter < bool > ("DQMStore", false)) {
    dbe_->setVerbose(0);
  }
  
  dirname_ = iConfig.getUntrackedParameter("dirname", std::string("HLT/FourVector/"));
  //dirname_ +=  iConfig.getParameter<std::string>("@module_label");
   
  if (dbe_ != 0 ) {
    dbe_->setCurrentFolder(dirname_);
  }


  doCombineRuns_ = iConfig.getUntrackedParameter<bool>("doCombineRuns", false);
  
  processname_ = iConfig.getParameter<std::string>("processname");
  fCustomBXPath = iConfig.getUntrackedParameter<std::string>("customBXPath", std::string("HLT_MinBiasBSC"));

  referenceBX_ = iConfig.getUntrackedParameter<unsigned int>("referenceBX",51);
  Nbx_ = iConfig.getUntrackedParameter<unsigned int>("Nbx",3564);

  // plotting paramters
  ptMin_ = iConfig.getUntrackedParameter<double>("ptMin",0.);
  ptMax_ = iConfig.getUntrackedParameter<double>("ptMax",1000.);
  nBins_ = iConfig.getUntrackedParameter<unsigned int>("Nbins",20);
  nBins2D_ = iConfig.getUntrackedParameter<unsigned int>("Nbins2D",40);
  dRMax_ = iConfig.getUntrackedParameter<double>("dRMax",1.0);
  nBinsDR_ = iConfig.getUntrackedParameter<unsigned int>("NbinsDR",10);
  nBinsOneOverEt_ = iConfig.getUntrackedParameter<unsigned int>("NbinsOneOverEt",10000);
  nLS_   = iConfig.getUntrackedParameter<unsigned int>("NLuminositySegments",10);
  LSsize_   = iConfig.getUntrackedParameter<double>("LuminositySegmentSize",23);
  thresholdFactor_ = iConfig.getUntrackedParameter<double>("thresholdFactor",1.5);

  
  plotAll_ = iConfig.getUntrackedParameter<bool>("plotAll", false);
     // this is the list of paths to look at.
  std::vector<edm::ParameterSet> paths = 
  iConfig.getParameter<std::vector<edm::ParameterSet> >("paths");

  for(std::vector<edm::ParameterSet>::iterator pathconf = paths.begin() ; pathconf != paths.end(); pathconf++) {

    //std::pair<std::string, std::string> custompathnamepair;
    //custompathnamepair.first =pathconf->getParameter<std::string>("pathname"); 
    //custompathnamepair.second = pathconf->getParameter<std::string>("denompathname");   
    //custompathnamepairs_.push_back(custompathnamepair);
    custompathnamepairs_.push_back(
        make_pair(
          pathconf->getParameter<std::string>("pathname"),
          pathconf->getParameter<std::string>("denompathname")
        )
    );

  }

  if (hltPaths_.size() > 0)
  {
      // book a histogram of scalers
     scalersSelect = dbe_->book1D("selectedScalers","Selected Scalers", hltPaths_.size(), 0.0, (double)hltPaths_.size());

  }

  triggerSummaryLabel_ = iConfig.getParameter<edm::InputTag>("triggerSummaryLabel");
  triggerResultsLabel_ = iConfig.getParameter<edm::InputTag>("triggerResultsLabel");
  triggerSummaryToken     = consumes <trigger::TriggerEvent> (triggerSummaryLabel_);
  triggerResultsToken     = consumes <TriggerResults> (triggerResultsLabel_);
  triggerSummaryFUToken   = consumes <trigger::TriggerEvent> (edm::InputTag(triggerSummaryLabel_.label(),triggerSummaryLabel_.instance(),std::string("FU")));
  triggerResultsFUToken   = consumes <TriggerResults> (edm::InputTag(triggerResultsLabel_.label(),triggerResultsLabel_.instance(),std::string("FU")));
  muonRecoCollectionToken = consumes <reco::MuonCollection> (iConfig.getUntrackedParameter("muonRecoCollectionName", std::string("muons")));

  beamSpotToken           = consumes <reco::BeamSpot> (std::string("offlineBeamSpot"));
  gsfElectronToken        = consumes <reco::GsfElectronCollection> (std::string("gsfElectrons"));
  tauProdToken            = consumes <std::vector<reco::PFTau> > (std::string("caloRecoTauProducer"));
  iC5calojetToken         = consumes <reco::CaloJetCollection> (std::string("iterativeCone5CaloJets"));
  jlipBtagToken           = consumes <reco::JetTagCollection> (std::string("jetProbabilityBJetTags"));
  softMuBtagToken         = consumes <reco::JetTagCollection> (std::string("softMuonBJetTags"));
  METToken                = consumes <reco::CaloMETCollection> (std::string("met"));
  photonToken             = consumes <reco::PhotonCollection> (std::string("photons"));
  pixelTrackToken         = consumes <reco::TrackCollection> (std::string("pixelTracks"));
  hpsPFTauProdToken       = consumes <std::vector<reco::PFTau> > (std::string("hpsPFTauProducer"));

  electronEtaMax_ = iConfig.getUntrackedParameter<double>("electronEtaMax",2.5);
  electronEtMin_ = iConfig.getUntrackedParameter<double>("electronEtMin",3.0);
  electronDRMatch_  =iConfig.getUntrackedParameter<double>("electronDRMatch",0.3); 
  electronL1DRMatch_  =iConfig.getUntrackedParameter<double>("electronL1DRMatch",0.3); 

  muonEtaMax_ = iConfig.getUntrackedParameter<double>("muonEtaMax",2.1);
  muonEtMin_ = iConfig.getUntrackedParameter<double>("muonEtMin",3.0);
  muonDRMatch_  =iConfig.getUntrackedParameter<double>("muonDRMatch",0.3); 
  muonL1DRMatch_  =iConfig.getUntrackedParameter<double>("muonL1DRMatch",0.3); 

  tauEtaMax_ = iConfig.getUntrackedParameter<double>("tauEtaMax",2.5);
  tauEtMin_ = iConfig.getUntrackedParameter<double>("tauEtMin",3.0);
  tauDRMatch_  =iConfig.getUntrackedParameter<double>("tauDRMatch",0.3); 
  tauL1DRMatch_  =iConfig.getUntrackedParameter<double>("tauL1DRMatch",0.5); 

  jetEtaMax_ = iConfig.getUntrackedParameter<double>("jetEtaMax",5.0);
  jetEtMin_ = iConfig.getUntrackedParameter<double>("jetEtMin",10.0);
  jetDRMatch_  =iConfig.getUntrackedParameter<double>("jetDRMatch",0.3); 
  jetL1DRMatch_  =iConfig.getUntrackedParameter<double>("jetL1DRMatch",0.5); 

  bjetEtaMax_ = iConfig.getUntrackedParameter<double>("bjetEtaMax",2.5);
  bjetEtMin_ = iConfig.getUntrackedParameter<double>("bjetEtMin",10.0);
  bjetDRMatch_  =iConfig.getUntrackedParameter<double>("bjetDRMatch",0.3); 
  bjetL1DRMatch_  =iConfig.getUntrackedParameter<double>("bjetL1DRMatch",0.3); 

  photonEtaMax_ = iConfig.getUntrackedParameter<double>("photonEtaMax",2.5);
  photonEtMin_ = iConfig.getUntrackedParameter<double>("photonEtMin",3.0);
  photonDRMatch_  =iConfig.getUntrackedParameter<double>("photonDRMatch",0.3); 
  photonL1DRMatch_  =iConfig.getUntrackedParameter<double>("photonL1DRMatch",0.3); 

  trackEtaMax_ = iConfig.getUntrackedParameter<double>("trackEtaMax",2.5);
  trackEtMin_ = iConfig.getUntrackedParameter<double>("trackEtMin",3.0);
  trackDRMatch_  =iConfig.getUntrackedParameter<double>("trackDRMatch",0.3); 
  trackL1DRMatch_  =iConfig.getUntrackedParameter<double>("trackL1DRMatch",0.3); 

  metEtaMax_ = iConfig.getUntrackedParameter<double>("metEtaMax",5);
  metMin_ = iConfig.getUntrackedParameter<double>("metMin",10.0);
  metDRMatch_  =iConfig.getUntrackedParameter<double>("metDRMatch",0.5); 
  metL1DRMatch_  =iConfig.getUntrackedParameter<double>("metL1DRMatch",0.5); 

  htEtaMax_ = iConfig.getUntrackedParameter<double>("htEtaMax",5);
  htMin_ = iConfig.getUntrackedParameter<double>("htMin",10.0);
  htDRMatch_  =iConfig.getUntrackedParameter<double>("htDRMatch",0.5); 
  htL1DRMatch_  =iConfig.getUntrackedParameter<double>("htL1DRMatch",0.5); 

  sumEtMin_ = iConfig.getUntrackedParameter<double>("sumEtMin",10.0);

  // Muon quality cuts
  dxyCut_ = iConfig.getUntrackedParameter<double>("DxyCut", 0.2);   // dxy < 0.2 cm 
  normalizedChi2Cut_ = iConfig.getUntrackedParameter<double>("NormalizedChi2Cut", 10.); // chi2/ndof (of global fit) <10.0
  trackerHitsCut_ = iConfig.getUntrackedParameter<int>("TrackerHitsCut", 11);  // Tracker Hits >10 
  pixelHitsCut_ = iConfig.getUntrackedParameter<int>("PixelHitsCut", 1); // Pixel Hits >0
  muonHitsCut_ = iConfig.getUntrackedParameter<int>("MuonHitsCut", 1);  // Valid Muon Hits >0 
  isAlsoTrackerMuon_ = iConfig.getUntrackedParameter<bool>("IsAlsoTrackerMuon", true);
  nMatchesCut_ = iConfig.getUntrackedParameter<int>("NMatchesCut", 2); // At least 2 Chambers with matches 

  // Electron quality cuts
    eleMaxOver3x3_  =  iConfig.getUntrackedParameter<double>("eleMaxOver3x3", 0.9);
  // Ecal Barrel
  dr03TkSumPtEB_ =  iConfig.getUntrackedParameter<double>("dr03TkSumPtEB", 3.0);
    dr04EcalRecHitSumEtEB_ = iConfig.getUntrackedParameter<double>("dr04EcalRecHitSumEtEB", 4.0);
    dr04HcalTowerSumEtEB_ =  iConfig.getUntrackedParameter<double>("dr04HcalTowerSumEtEB", 5.0);
    hadronicOverEmEB_ =    iConfig.getUntrackedParameter<double>("hadronicOverEmEB", 0.05);
    deltaPhiSuperClusterTrackAtVtxEB_ = iConfig.getUntrackedParameter<double>("deltaPhiSuperClusterTrackAtVtxEB", 0.2);
    deltaEtaSuperClusterTrackAtVtxEB_ = iConfig.getUntrackedParameter<double>("deltaEtaSuperClusterTrackAtVtxEB", 0.006);
    sigmaIetaIetaEB_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaEB", 0.01);
  //spikes
    sigmaIetaIetaSpikesEB_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaSpikesEB", 0.002);

  // Ecal Endcap
    dr03TkSumPtEC_ =  iConfig.getUntrackedParameter<double>("dr03TkSumPtEC", 1.5);
    dr04EcalRecHitSumEtEC_ = iConfig.getUntrackedParameter<double>("dr04EcalRecHitSumEtEC", 2.5);
    dr04HcalTowerSumEtEC_ =  iConfig.getUntrackedParameter<double>("dr04HcalTowerSumEtEC", 0.7);
    hadronicOverEmEC_ =  iConfig.getUntrackedParameter<double>("hadronicOverEmEC", 0.025);
    deltaPhiSuperClusterTrackAtVtxEC_ = iConfig.getUntrackedParameter<double>("deltaPhiSuperClusterTrackAtVtxEC", 0.2);
    deltaEtaSuperClusterTrackAtVtxEC_ = iConfig.getUntrackedParameter<double>("deltaEtaSuperClusterTrackAtVtxEC", 0.006);
    sigmaIetaIetaEC_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaEC", 0.03);
  //spikes
    sigmaIetaIetaSpikesEC_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaSpikesEC", 0.002);

  // Jet ID cuts
  emEnergyFractionJet_ = iConfig.getUntrackedParameter<double>("emEnergyFractionJet",0.01);
  fHPDJet_ = iConfig.getUntrackedParameter<double>("fHPDJet",0.98);
  n90Jet_ = iConfig.getUntrackedParameter<int>("n90Jet",2);

  // Tau discriminators
  tauDscrmtr1Token = consumes <reco::PFTauDiscriminator>  (iConfig.getUntrackedParameter("tauDscrmtrLabel1", std::string("shrinkingConePFTauDiscriminationByLeadingTrackFinding")));
  tauDscrmtr2Token = consumes <reco::PFTauDiscriminator>  (iConfig.getUntrackedParameter("tauDscrmtrLabel2", std::string("shrinkingConePFTauDiscriminationByLeadingTrackPtCut")));
  tauDscrmtr3Token = consumes <reco::PFTauDiscriminator>  (iConfig.getUntrackedParameter("tauDscrmtrLabel3", std::string("shrinkingConePFTauDiscriminationByIsolation")));

  specialPaths_ = iConfig.getParameter<std::vector<std::string > >("SpecialPaths");

  pathsSummaryFolder_ = iConfig.getUntrackedParameter ("pathsSummaryFolder",std::string("HLT/FourVector/PathsSummary/"));
  pathsSummaryHLTCorrelationsFolder_ = iConfig.getUntrackedParameter ("hltCorrelationsFolder",std::string("HLT/FourVector/PathsSummary/HLT Correlations/"));
  pathsSummaryFilterCountsFolder_ = iConfig.getUntrackedParameter ("filterCountsFolder",std::string("HLT/FourVector/PathsSummary/Filters Counts/"));

  pathsSummaryHLTPathsPerLSFolder_ = iConfig.getUntrackedParameter ("pathsPerLSFolder",std::string("HLT/FourVector/PathsSummary/HLT LS/"));
  //  pathsIndividualHLTPathsPerLSFolder_ = iConfig.getUntrackedParameter ("individualPathsPerLSFolder",std::string("HLT/FourVector/PathsSummary/HLT LS/Paths/"));
  //  pathsSummaryHLTPathsPerBXFolder_ = iConfig.getUntrackedParameter ("individualPathsPerBXFolder",std::string("HLT/FourVector/PathsSummary/HLT BX/"));

  fLumiFlag = true;
  ME_HLTAll_LS = NULL;
  ME_HLT_BX = NULL;
  ME_HLT_CUSTOM_BX = NULL;

  jetID = new reco::helper::JetIDHelper(iConfig.getParameter<ParameterSet>("JetIDParams"), consumesCollector());
  
  recHitsEBTag_ = iConfig.getUntrackedParameter<edm::InputTag>("RecHitsEBTag",edm::InputTag("reducedEcalRecHitsEB"));
  recHitsEETag_ = iConfig.getUntrackedParameter<edm::InputTag>("RecHitsEETag",edm::InputTag("reducedEcalRecHitsEE"));
  recHitsEBToken    = consumes <edm::SortedCollection<EcalRecHit> > (recHitsEBTag_);
  recHitsEEToken    = consumes <edm::SortedCollection<EcalRecHit> > (recHitsEETag_);
  
}

FourVectorHLTOffline::~FourVectorHLTOffline

(

)

Definition at line 231 of file FourVectorHLTOffline.cc.

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

{
 
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)
  delete fSelectedMuons;
  delete fSelectedElectrons;
  delete fSelectedPhotons;
  delete fSelectedJets;
  delete fSelectedMet;
  delete fSelectedTaus;

}

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.

{

  //if(! fLumiFlag ) return;

  using namespace edm;
  using namespace trigger;
  ++nev_;
  LogDebug("FourVectorHLTOffline")<< " analyze...." ;

  edm::Handle<TriggerResults> triggerResults;
  iEvent.getByToken(triggerResultsToken,triggerResults);
  if(!triggerResults.isValid()) {
    iEvent.getByToken(triggerResultsFUToken,triggerResults);
  if(!triggerResults.isValid()) {
    edm::LogInfo("FourVectorHLTOffline") << "TriggerResults not found, "
      "skipping event"; 
    return;
  }
  }
  fTriggerResults = triggerResults;
  const edm::TriggerNames & triggerNames = iEvent.triggerNames(*triggerResults);
  int npath = triggerResults->size();

  iEvent.getByToken(triggerSummaryToken,fTriggerObj); 
  if(!fTriggerObj.isValid()) {

    iEvent.getByToken(triggerSummaryFUToken,fTriggerObj);

    if(!fTriggerObj.isValid()) {

      edm::LogInfo("FourVectorHLTOffline") << "TriggerEvent not found, " "skipping event"; 
      return;

    }

  }

  // Beam spot
  if (!iEvent.getByToken(beamSpotToken, fBeamSpotHandle)) {
        edm::LogInfo("") << ">>> No beam spot found !!!";
  }

  edm::Handle<reco::MuonCollection> muonHandle;
  iEvent.getByToken(muonRecoCollectionToken,muonHandle);
  if(!muonHandle.isValid())  
    edm::LogInfo("FourVectorHLTOffline") << "muonHandle not found, ";
  selectMuons(muonHandle);

  edm::Handle<reco::GsfElectronCollection> gsfElectrons;
  iEvent.getByToken(gsfElectronToken,gsfElectrons); 
  if(!gsfElectrons.isValid()) 
    edm::LogInfo("FourVectorHLTOffline") << "gsfElectrons not found, ";
  selectElectrons(iEvent, iSetup, gsfElectrons);

  //edm::Handle<reco::CaloTauCollection> tauHandle;
  edm::Handle<reco::PFTauCollection> tauHandle;
  iEvent.getByToken(tauProdToken,tauHandle);
  if(!tauHandle.isValid()) 
    edm::LogInfo("FourVectorHLTOffline") << "tauHandle not found, ";
  //selectTaus(tauHandle);
  selectTaus(iEvent);

  edm::Handle<reco::CaloJetCollection> jetHandle;
  iEvent.getByToken(iC5calojetToken,jetHandle);
  if(!jetHandle.isValid()) 
    edm::LogInfo("FourVectorHLTOffline") << "jetHandle not found, ";
  selectJets(iEvent,jetHandle);

   // Get b tag information
 edm::Handle<reco::JetTagCollection> bTagIPHandle;
 iEvent.getByToken(jlipBtagToken, bTagIPHandle);
 if (!bTagIPHandle.isValid()) 
    edm::LogInfo("FourVectorHLTOffline") << "mTagIPHandle trackCountingHighEffJetTags not found, ";

   // Get b tag information
 edm::Handle<reco::JetTagCollection> bTagMuHandle;
 iEvent.getByToken(softMuBtagToken, bTagMuHandle);
 if (!bTagMuHandle.isValid()) 
    edm::LogInfo("FourVectorHLTOffline") << "bTagMuHandle  not found, ";

  edm::Handle<reco::CaloMETCollection> metHandle;
  iEvent.getByToken(METToken,metHandle);
  if(!metHandle.isValid()) 
    edm::LogInfo("FourVectorHLTOffline") << "metHandle not found, ";
  selectMet(metHandle);

  edm::Handle<reco::PhotonCollection> photonHandle;
  iEvent.getByToken(photonToken,photonHandle);
  if(!photonHandle.isValid()) 
    edm::LogInfo("FourVectorHLTOffline") << "photonHandle not found, ";
  selectPhotons(photonHandle);

  edm::Handle<reco::TrackCollection> trackHandle;
  iEvent.getByToken(pixelTrackToken,trackHandle);
  if(!trackHandle.isValid()) 
    edm::LogInfo("FourVectorHLTOffline") << "trackHandle not found, ";


  // ---------------------
  // Monitors
  // ---------------------

  // electron Monitor
  objMonData<reco::GsfElectronCollection> eleMon;
  //eleMon.setReco(gsfElectrons);
  eleMon.setReco(fSelElectronsHandle);
  eleMon.setRecoEle(fSelElectronsHandle);
  eleMon.setLimits(electronEtaMax_, electronEtMin_, electronDRMatch_, electronL1DRMatch_, dRMax_, thresholdFactor_);
  
  eleMon.pushTriggerType(TriggerElectron);
  eleMon.pushTriggerType(TriggerL1NoIsoEG);
  eleMon.pushTriggerType(TriggerL1IsoEG);

  eleMon.pushL1TriggerType(TriggerL1NoIsoEG);
  eleMon.pushL1TriggerType(TriggerL1IsoEG);

  // muon Monitor
  objMonData<reco::MuonCollection>  muoMon;
  //muoMon.setReco(muonHandle);
  muoMon.setReco(fSelMuonsHandle);
  muoMon.setRecoMu(fSelMuonsHandle);
  muoMon.setLimits(muonEtaMax_, muonEtMin_, muonDRMatch_, muonL1DRMatch_, dRMax_, thresholdFactor_);
  
  muoMon.pushTriggerType(TriggerMuon);
  muoMon.pushTriggerType(TriggerL1Mu);

  muoMon.pushL1TriggerType(TriggerL1Mu);
  
  // tau Monitor
  //objMonData<reco::CaloTauCollection>  tauMon;
  objMonData<reco::PFTauCollection>  tauMon;
  //tauMon.setReco(tauHandle);
  tauMon.setReco(fSelTausHandle);
  tauMon.setLimits(tauEtaMax_, tauEtMin_, tauDRMatch_, tauL1DRMatch_, dRMax_, thresholdFactor_);
  
  tauMon.pushTriggerType(TriggerTau);
  tauMon.pushTriggerType(TriggerL1TauJet);

  tauMon.pushL1TriggerType(TriggerL1TauJet);
  tauMon.pushL1TriggerType(TriggerL1ForJet);
  
  // photon Monitor
  //objMonData<reco::PhotonCollection> phoMon;
  //phoMon.setReco(photonHandle);
  //phoMon.setReco(fSelPhotonsHandle);
  // -----------------------------------------------
  // Use RECO Electrons instead of RECO Photons 
  // to measure HLT_Photon efficiency
  // -----------------------------------------------
  objMonData<reco::GsfElectronCollection> phoMon;
  phoMon.setReco(fSelElectronsHandle);
  phoMon.setRecoEle(fSelElectronsHandle);
  

  phoMon.setLimits(photonEtaMax_, photonEtMin_, photonDRMatch_, photonL1DRMatch_, dRMax_, thresholdFactor_);
  
  phoMon.pushTriggerType(TriggerPhoton);

  phoMon.pushL1TriggerType(TriggerL1NoIsoEG);
  phoMon.pushL1TriggerType(TriggerL1IsoEG);

  // jet Monitor - NOTICE: we use genJets for MC
  objMonData<reco::CaloJetCollection> jetMon;
  //jetMon.setReco(jetHandle);
  jetMon.setReco(fSelJetsHandle);
  jetMon.setLimits(jetEtaMax_, jetEtMin_, jetDRMatch_, jetL1DRMatch_, dRMax_, thresholdFactor_);

  jetMon.pushTriggerType(TriggerJet);
  jetMon.pushTriggerType(TriggerL1CenJet);
  jetMon.pushTriggerType(TriggerL1ForJet);
  
  jetMon.pushL1TriggerType(TriggerL1CenJet);
  jetMon.pushL1TriggerType(TriggerL1ForJet);
  jetMon.pushL1TriggerType(TriggerL1TauJet);

  // bjet Monitor - NOTICE: we use genJets for MC
  objMonData<reco::CaloJetCollection> btagIPMon; // CaloJet will not be used, this is only place holder
  //btagIPMon.setReco(jetHandle);
  btagIPMon.setRecoB(bTagIPHandle);
  btagIPMon.setBJetsFlag(true);
  btagIPMon.setLimits(bjetEtaMax_, bjetEtMin_, bjetDRMatch_, bjetL1DRMatch_, dRMax_, thresholdFactor_);

  btagIPMon.pushTriggerType(TriggerBJet);
  btagIPMon.pushTriggerType(TriggerJet);

  btagIPMon.pushL1TriggerType(TriggerL1CenJet);
  btagIPMon.pushL1TriggerType(TriggerL1ForJet);
  btagIPMon.pushL1TriggerType(TriggerL1TauJet);

  objMonData<reco::CaloJetCollection> btagMuMon; // CaloJet will not be used, this is only place holder
  //btagMuMon.setReco(jetHandle);
  btagMuMon.setRecoB(bTagMuHandle);
  btagMuMon.setBJetsFlag(true);
  btagMuMon.setLimits(bjetEtaMax_, bjetEtMin_, bjetDRMatch_, bjetL1DRMatch_, dRMax_, thresholdFactor_);

  btagMuMon.pushTriggerType(TriggerBJet);
  btagMuMon.pushTriggerType(TriggerJet);

  btagMuMon.pushL1TriggerType(TriggerL1CenJet);
  btagMuMon.pushL1TriggerType(TriggerL1ForJet);
  btagMuMon.pushL1TriggerType(TriggerL1TauJet);


  objMonData<reco::CaloJetCollection> btagMon; // Generic btagMon
 
  // met Monitor
  objMonData<reco::CaloMETCollection> metMon;
  //metMon.setReco(metHandle);
  metMon.setReco(fSelMetHandle);
  metMon.setLimits(metEtaMax_, metMin_, metDRMatch_, metL1DRMatch_, dRMax_, thresholdFactor_);
  
  metMon.pushTriggerType(TriggerMET);

  metMon.pushL1TriggerType(TriggerL1ETM);

  // tet Monitor
  objMonData<reco::CaloMETCollection> tetMon;
  //tetMon.setReco(metHandle);
  tetMon.setReco(fSelMetHandle);
  //tetMon.setLimits(tetEtaMax_=999., tetEtMin_=10, tetDRMatch_=999);
  tetMon.setLimits(999., 10., 999., 999., dRMax_, thresholdFactor_);
  
  tetMon.pushTriggerType(TriggerTET);

  tetMon.pushL1TriggerType(TriggerL1ETT);

  // default Monitor
  //objMonData<trigger::TriggerEvent> defMon;
  objMonData<reco::CaloMETCollection> defMon;
  defMon.setLimits(999., 3., 999., 999., dRMax_, thresholdFactor_);

  // vector to hold monitors 
  // interface is through virtual class BaseMonitor
  std::vector<BaseMonitor*> monitors;

  //monitors.push_back(&jetMon);

  monitors.push_back(&muoMon);
  monitors.push_back(&eleMon);
  monitors.push_back(&tauMon);
  monitors.push_back(&phoMon);
  monitors.push_back(&jetMon);
  monitors.push_back(&btagMon);
  monitors.push_back(&metMon);
  monitors.push_back(&tetMon);
  /*
  */

  //  int bx = iEvent.bunchCrossing();
  /*
  // Fill HLTPassed_Correlation Matrix bin (i,j) = (Any,Any)
  // --------------------------------------------------------
  int anyBinNumber = ME_HLTPassPass_->getTH2F()->GetXaxis()->FindBin("HLT_Any");      
  // any triger accepted
  if(triggerResults->accept()){

    ME_HLTPassPass_->Fill(anyBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter

  }
  */

  fillHltMatrix(triggerNames);


  // Loop over paths
  // --------------------
  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) { 

    LogTrace("FourVectorHLTOffline") << " unique path " << v->getPath() << endl;

    unsigned int pathByIndex = triggerNames.triggerIndex(v->getPath());

    // path must be in the menu
    if(pathByIndex >= fTriggerResults->size() ) continue;

  
    // Fill HLTPassed Matrix and HLTPassFail Matrix
    // --------------------------------------------------------

//     if(triggerResults->accept(pathByIndex)){
  
//       int pathBinNumber = ME_HLT_BX->getTH2F()->GetYaxis()->FindBin(v->getPath().c_str());      
//       ME_HLT_BX->Fill(bx,pathBinNumber-1);

//       //if(hasHLTPassed(fCustomBXPath,triggerNames)) {

//         //ME_HLT_CUSTOM_BX->Fill(bx,pathBinNumber-1);

//       //}

//     } // end if accept
  
    // Fill histogram of filter ocupancy for each HLT path
    // ---------------------------------
    unsigned int lastModule = triggerResults->index(pathByIndex);

    //check if hlt passed
    bool hltPathPassed = triggerResults->accept(pathByIndex);
  
    //go through the list of filters
    for(unsigned int filt = 0; filt < v->filtersAndIndices.size(); filt++){
      
      int binNumber = v->getFiltersHisto()->getTH1()->GetXaxis()->FindBin(v->filtersAndIndices[filt].first.c_str());      
      
      // if hlt path passed, then all the modules passed
      // otherwise the module that issued the decision is the first fail
      // this means that all modules before it passed
      if(hltPathPassed) {

        v->getFiltersHisto()->Fill(binNumber-1);//binNumber1 = 0 = first filter
      }
      else if(v->filtersAndIndices[filt].second < lastModule){
        v->getFiltersHisto()->Fill(binNumber-1);//binNumber1 = 0 = first filter
      }
  
    } // end for filt

  } // end for diag paths

  // Main loop over paths
  // --------------------
  for(PathInfoCollection::iterator v = hltPaths_.begin(); v!= hltPaths_.end(); ++v ) { 

    LogTrace("FourVectorHLTOffline") << " path " << v->getPath() << endl;

    if (v->getPath().find("BTagIP") != std::string::npos ) btagMon = btagIPMon;
    else btagMon = btagMuMon;

    // set flag for muon monitor if L2-muon or L1-muon type path
    if (v->getPath().find("L2Mu") != std::string::npos || v->getPath().find("L1Mu") != std::string::npos ) muoMon.setL2MuFlag(true);
    else muoMon.setL2MuFlag(false);

    //if (v->getPath().find("HLT_Jet15U") == std::string::npos ) continue;
    //if(*v != "HLT_L1Jet6U") continue;

    unsigned int pathByIndex = triggerNames.triggerIndex(v->getPath());

    if(pathByIndex >= fTriggerResults->size() ) continue;
  
    // did we pass the denomPath?
    bool denompassed = false;  

    for(int i = 0; i < npath; ++i) {

     if (triggerResults->accept(i) && triggerNames.triggerName(i).find(v->getDenomPath()) != std::string::npos && triggerNames.triggerName(i).find("HLT_Mult") == std::string::npos )
     { 
        denompassed = true;
        break;
     }
   }

   if (denompassed)
   {  

     //LogTrace("FourVectorHLTOffline") << " denominator path " << v->getPath() << endl;


     // Get the righe monitor for this path
     // -----------------------------------
     BaseMonitor* mon = NULL;

     for(std::vector<BaseMonitor*>::iterator mit = monitors.begin(); mit!= monitors.end(); ++mit ) {
       
       if((*mit)->isTriggerType(v->getObjectType())) {

         mon = *mit;
         break;

       }

     }

     // if cannot find moniotor for the path, go to next path
     //if(!mon) continue;

     // if cannot find moniotor for the path, assign the default
     if(!mon) mon = &defMon;

     // attach this path to mon
     mon->setPath(v);

     // clear sets of matched objects
     mon->clearSets();

     v->getObjectType();

     // monitor offline (RECO objects)
     mon->monitorOffline();

     // monitor L1 (only if L1 passed and can find GTSeed)
     bool l1accept = false;
     edm::InputTag l1testTag(v->getl1Path(),"",processname_);
     const int l1Index = fTriggerObj->filterIndex(l1testTag);
     
     if ( l1Index >= fTriggerObj->sizeFilters() ) {

       LogTrace("FourVectorHLTOffline") << "Cannot find L1GTSeed of the path " << v->getPath() << endl;
       LogTrace("FourVectorHLTOffline") << "\t L1GTSeed name = " << v->getl1Path() << endl;
       LogTrace("FourVectorHLTOffline") <<  "\t tried with tag " << l1testTag << endl;
       LogTrace("FourVectorHLTOffline") <<"\t module index = "<< l1Index << endl;

     } 

       // monitor L1 object
       mon->monitorL1(l1Index, this);
    
       // fill matching b/w Offline and L1 objects
       mon->fillL1Match(this);
    
    // monitor Online (only if HLT passed)
      bool numpassed = false;

    // did we pass the numerator path, i.e. HLT path?
    for(int i = 0; i < npath; ++i) {

      if ( triggerResults->accept(i) && triggerNames.triggerName(i) == v->getPath() ) numpassed = true;

    }

    if (!numpassed) continue;

    if (!l1accept) {

          LogDebug("FourVectorHLTOffline") 
            << "This should not happen.  HLT passed, but L1 Seed not passed for hlt path "<< endl 
            << "HLT path: " << v->getPath() << "\t HLTLevel1GTSeed: " << v->getl1Path();

    }

    // fill scaler histograms
    edm::InputTag filterTag = v->getTag();

    // loop through indices and see if the filter is 
    // on the list of filters used by this path
    //----------------------------------------------
    if (v->getLabel() == "dummy"){
    const vector<string> filterLabels = hltConfig_.moduleLabels(v->getPath());

    //loop over labels
    for (vector<string>::const_iterator labelIter= filterLabels.begin(); labelIter!=filterLabels.end(); labelIter++) {

      edm::InputTag testTag(*labelIter,"",processname_);

      int testindex = fTriggerObj->filterIndex(testTag);

      // last match wins...
      if ( !(testindex >= fTriggerObj->sizeFilters()) ) {

        filterTag = testTag; 
        v->setLabel(*labelIter);}

      }

    } // end for
  
    const int hltIndex = fTriggerObj->filterIndex(filterTag);
    if ( hltIndex >= fTriggerObj->sizeFilters() ) {

      LogTrace("FourVectorHLTOffline") << "WTF no index "<< hltIndex << " of that name " << filterTag << endl;
      continue; // not in this event

    }

    mon->monitorOnline(hltIndex, l1Index, this);

    mon->fillOnlineMatch(l1Index, this);

   } //denompassed


 } //pathinfo loop

}

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

{
  nev_ = 0;
  DQMStore *dbe = 0;
  dbe = Service<DQMStore>().operator->();
  
  if (dbe) {
    dbe->setCurrentFolder(dirname_);
    dbe->rmdir(dirname_);
  }
  
  
  if (dbe) {
    dbe->setCurrentFolder(dirname_);
    }  
}

void FourVectorHLTOffline::beginLuminosityBlock ( const edm::LuminosityBlock &  lumiSeg, const edm::EventSetup &  c  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1775 of file FourVectorHLTOffline.cc.

                                                                                                        {   

   //int lumi = int(lumiSeg.id().luminosityBlock());
   //if(lumi < 74 || lumi > 77) fLumiFlag = false;
   //else fLumiFlag = true;

}

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(), dt-layouts::histoname, 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.

{

  LogDebug("FourVectorHLTOffline") << "beginRun, run " << run.id();

  if(fIsSetup) return;
  
  // HLT config does not change within runs!
  bool changed=false;
 
  if (!hltConfig_.init(run, c, processname_, changed)) {

    processname_ = "FU";

    if (!hltConfig_.init(run, c, processname_, changed)){

      LogDebug("FourVectorHLTOffline") << "HLTConfigProvider failed to initialize.";

    }

    // check if trigger name in (new) config
    //  cout << "Available TriggerNames are: " << endl;
    //  hltConfig_.dump("Triggers");
  }

  if (1) {

    DQMStore *dbe = 0;
    dbe = Service<DQMStore>().operator->();
  
    if (dbe) {
      dbe->setCurrentFolder(dirname_);
    }

    const unsigned int n(hltConfig_.size());

    if (plotAll_){

      for (unsigned int j=0; j!=n; ++j) {
  
        std::string pathname = hltConfig_.triggerName(j);  

        string l1pathname = getL1ConditionModuleName(pathname);

        int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
      
        int objectType =  getTriggerTypeParsePathName(pathname);
  
        for (unsigned int i=0; i!=n; ++i) {
  
          std::string denompathname = hltConfig_.triggerName(i);  
          int denomobjectType =  getTriggerTypeParsePathName(denompathname);

      
         
          std::string filtername("dummy");
          float ptMin = 0.0;
          float ptMax = 100.0;
          if (plotAll_ && denomobjectType == objectType && objectType != 0) {
          
            int hltThreshold = getHltThresholdFromName(pathname);
            int l1Threshold = getHltThresholdFromName(l1pathname);
            hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));

          }

        }
      }

    } // end if plotAll
    else {

      // plot all diagonal combinations plus any other specified pairs
      for (unsigned int i=0; i!=n; ++i) {

         std::string denompathname = "";  
         std::string pathname = hltConfig_.triggerName(i);  
         //parse pathname to guess object type
         int objectType =  getTriggerTypeParsePathName(pathname);

        string l1pathname = getL1ConditionModuleName(pathname);
        int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
  
        std::string filtername("dummy");
        float ptMin = 0.0;
        float ptMax = 100.0;

        if (objectType == trigger::TriggerPhoton) ptMax = 400.0;
        if (objectType == trigger::TriggerElectron) ptMax = 300.0;
        if (objectType == trigger::TriggerMuon) ptMax = 300.0;
        if (objectType == trigger::TriggerTau) ptMax = 300.0;
        if (objectType == trigger::TriggerJet) ptMax = 700.0;
        if (objectType == trigger::TriggerBJet) ptMax = 300.0;
        if (objectType == trigger::TriggerMET) ptMax = 500.0;
        if (objectType == trigger::TriggerTET) ptMax = 1000.0;
        if (objectType == trigger::TriggerTrack) ptMax = 100.0;
    
        // keep track of all paths, except for FinalPath
        if (objectType != -1 && pathname.find("FinalPath") == std::string::npos){

          int hltThreshold = getHltThresholdFromName(pathname);
          int l1Threshold = getHltThresholdFromName(l1pathname);
  
          hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));

          hltPathsDiagonal_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
  
        }

      } // end for i

      // now loop over denom/num path pairs specified in cfg, 
      // recording the off-diagonal ones
      for (std::vector<std::pair<std::string, std::string> >::iterator custompathnamepair = custompathnamepairs_.begin(); custompathnamepair != custompathnamepairs_.end(); ++custompathnamepair) {
            
        std::string numpathname = custompathnamepair->first;  
        std::string denompathname = custompathnamepair->second;  
  
        if (numpathname != denompathname) {
  
          // check that denominator exists
          bool founddenominator = false;
          for (unsigned int k=0; k!=n; ++k) {

            string n_pathname = hltConfig_.triggerName(k);

            if (n_pathname.find(denompathname) != std::string::npos) {
              
              LogDebug("FourVectorHLTOffline") << "denompathname is selected to be = " << n_pathname << endl;;
              founddenominator = true;

              break;

            }
          }

          if (!founddenominator) {
  
            edm::LogInfo("FourVectorHLTOffline") << "denompathname not found, go to the next pair numearator-denominator" << endl;
            
            // go to the next pair
            continue;
  
          }

          // check that numerator exists
          for (unsigned int j=0; j!=n; ++j) {
          bool foundnumerator = false;

            string pathname = hltConfig_.triggerName(j);

            LogDebug("FourVectorHLTOffline") << "check if path " << pathname << " is numpathname = " << numpathname << endl;
            if (hltConfig_.triggerName(j).find(numpathname)!= std::string::npos) {
              
              LogDebug("FourVectorHLTOffline") << "pathname is selected to be = " << denompathname << endl;;
              foundnumerator = true;

            }
  
  
            if (!foundnumerator) {
    
              edm::LogInfo("FourVectorHLTOffline") << "pathname not found, ignoring " << pathname;
              continue;
  
            }
  
            string l1pathname = getL1ConditionModuleName(pathname);
            int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
            int objectType =  getTriggerTypeParsePathName(pathname);
  
          std::string filtername("dummy");
          float ptMin = 0.0;
          float ptMax = 100.0;

        if (objectType == trigger::TriggerPhoton) ptMax = 400.0;
        if (objectType == trigger::TriggerElectron) ptMax = 300.0;
        if (objectType == trigger::TriggerMuon) ptMax = 300.0;
        if (objectType == trigger::TriggerTau) ptMax = 300.0;
        if (objectType == trigger::TriggerJet) ptMax = 700.0;
        if (objectType == trigger::TriggerBJet) ptMax = 300.0;
        if (objectType == trigger::TriggerMET) ptMax = 500.0;
        if (objectType == trigger::TriggerTET) ptMax = 1000.0;
        if (objectType == trigger::TriggerTrack) ptMax = 100.0;
  
          // monitor regardless of the objectType of the path
          if (objectType != 0) {
            int hltThreshold = getHltThresholdFromName(pathname);
            int l1Threshold = getHltThresholdFromName(l1pathname);
            hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));

          }
      
        } // end for j, loop over paths

       }  // end if not same num and denominator 
  
      } // end for pair

    } // end else


    vector<string> allPaths;
    // fill vectors of Muon, Egamma, JetMet, Rest, and Special paths

    int vi = 0;

    for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {

      std::string pathName = removeVersions(v->getPath());
      //int objectType = v->getObjectType();

      vector<int> tempCount(5,0);

      fPathTempCountPair.push_back(make_pair(pathName,0));
      fPathBxTempCountPair.push_back(make_pair(pathName,tempCount));

      allPaths.push_back(pathName);

    }
    
    fPathTempCountPair.push_back(make_pair("HLT_Any",0));

    fGroupName.push_back("All");

    for(unsigned int g=0; g<fGroupName.size(); g++) {

      //fGroupTempCountPair.push_back(make_pair(fGroupName[g],0));
      //fGroupL1TempCountPair.push_back(make_pair(fGroupName[g],0));

    }
  
    dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());

    fGroupNamePathsPair.push_back(make_pair("All",allPaths));

    vector<string> datasetNames =  hltConfig_.datasetNames() ;
    for (unsigned int i=0;i<datasetNames.size();i++) {

      vector<string> datasetPaths = hltConfig_.datasetContent(datasetNames[i]);
      fGroupNamePathsPair.push_back(make_pair(datasetNames[i],datasetPaths));

    }


    for (unsigned int g=0;g<fGroupNamePathsPair.size();g++) {

      fGroupTempCountPair.push_back(make_pair(fGroupNamePathsPair[g].first,0));
      fGroupL1TempCountPair.push_back(make_pair(fGroupNamePathsPair[g].first,0));
      setupHltMatrix(fGroupNamePathsPair[g].first,fGroupNamePathsPair[g].second);

    }

    //    setupHltLsPlots();
    //    setupHltBxPlots();

    vi = 0;

    for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
      vi++;

       // -------------------------
       //
       //  Filters for each path
       //
       // -------------------------
       
       // get all modules in this HLT path
      std::string pathName = removeVersions(v->getPath());
      vector<string> moduleNames = hltConfig_.moduleLabels(v->getPath()); 

       int numModule = 0;
       string moduleName, moduleType, moduleEDMType;
       unsigned int moduleIndex;
       
       //print module name
       vector<string>::const_iterator iDumpModName;
       for (iDumpModName = moduleNames.begin();iDumpModName != moduleNames.end();iDumpModName++) {

         moduleName = *iDumpModName;
         moduleType = hltConfig_.moduleType(moduleName);
         moduleEDMType = hltConfig_.moduleEDMType(moduleName);
         moduleIndex = hltConfig_.moduleIndex(v->getPath(), moduleName);

         LogTrace ("FourVectorHLTOffline") << "Module "      << numModule
             << " is called " << moduleName
             << " , type = "  << moduleType
             << " , EDMtype = " << moduleEDMType 
             << " , index = " << moduleIndex
             << endl;

         numModule++;

         if((moduleType.find("Filter") != string::npos && moduleType.find("HLTTriggerTypeFilter") == string::npos ) || 
            (moduleType.find("Associator") != string::npos) || 
            (moduleType.find("HLTLevel1GTSeed") != string::npos) || 
            (moduleType.find("HLTGlobalSumsCaloMET") != string::npos) ||
            (moduleType.find("HLTPrescaler") != string::npos) || 
            (moduleEDMType.find("EDFilter") != string::npos) ) {

           //std::pair<std::string, int> filterIndexPair;
           //filterIndexPair.first   = moduleName;
           //filterIndexPair.second  = moduleIndex;
           //v->filtersAndIndices.push_back(filterIndexPair);
           v->filtersAndIndices.push_back(make_pair(moduleName,moduleIndex));

         }


       }//end for modulesName

       dbe_->setCurrentFolder(pathsSummaryFilterCountsFolder_.c_str()); 

       //int nbin_sub = 5;
       int nbin_sub = v->filtersAndIndices.size()+2;
    

       //TString thisPath = v->getPath();

       // count plots for subfilter
       MonitorElement* filters = dbe_->book1D("Filters_" + pathName, 
                          "Filters_" + pathName,
                              nbin_sub+1, -0.5, 0.5+(double)nbin_sub);
       
       for(unsigned int filt = 0; filt < v->filtersAndIndices.size(); filt++){

     if (filters)
       filters->setBinLabel(filt+1, (v->filtersAndIndices[filt]).first);

       }

       // bjk here
//        // book Count vs LS
//        dbe_->setCurrentFolder(pathsIndividualHLTPathsPerLSFolder_.c_str());
//        MonitorElement* tempME = dbe_->book1D(v->getPath() + "_count_per_LS", 
//                               pathName + " count per LS",
//                               nLS_, 0,nLS_);
//        tempME->setAxisTitle("Luminosity Section");

       v->setFilterHistos(filters);

    } // end for paths

    // now set up all of the histos for each path-denom
    for(PathInfoCollection::iterator v = hltPaths_.begin(); v!= hltPaths_.end(); ++v ) {

      MonitorElement *NOn=0; 
      MonitorElement   *onEtOn=0; 
      MonitorElement   *onOneOverEtOn=0; 
      MonitorElement   *onEtavsonPhiOn=0;
      MonitorElement *NOff=0; 
      MonitorElement   *offEtOff=0; 
      MonitorElement   *offEtavsoffPhiOff=0;
      MonitorElement *NL1=0; 
      MonitorElement   *l1EtL1=0; 
      MonitorElement   *l1Etavsl1PhiL1=0;
      MonitorElement *NL1On=0; 
      MonitorElement   *l1EtL1On=0; 
      MonitorElement   *l1Etavsl1PhiL1On=0;
      MonitorElement *NL1Off=0; 
      MonitorElement   *offEtL1Off=0; 
      MonitorElement   *offEtavsoffPhiL1Off=0;
      MonitorElement *NOnOff=0; 
      MonitorElement   *offEtOnOff=0; 
      MonitorElement   *offEtavsoffPhiOnOff=0;
      MonitorElement *NL1OnUM=0; 
      MonitorElement   *l1EtL1OnUM=0; 
      MonitorElement   *l1Etavsl1PhiL1OnUM=0;
      MonitorElement *NL1OffUM=0; 
      MonitorElement   *offEtL1OffUM=0; 
      MonitorElement   *offEtavsoffPhiL1OffUM=0;
      MonitorElement *NOnOffUM=0; 
      MonitorElement   *offEtOnOffUM=0; 
      MonitorElement   *offEtavsoffPhiOnOffUM=0;
      MonitorElement *offDRL1Off=0; 
      MonitorElement   *offDROnOff=0; 
      MonitorElement   *l1DRL1On=0;
      
      std::string pathName = removeVersions(v->getPath());
      std::string labelname("dummy");
      labelname = pathName + "_wrt_" + v->getDenomPath();

      std::string histoname(labelname+"_NOn");
      std::string title(labelname+" N online");
      double histEtaMax = 2.5;

      if (v->getObjectType() == trigger::TriggerMuon || v->getObjectType() == trigger::TriggerL1Mu) {

        histEtaMax = muonEtaMax_;

      }
      else if (v->getObjectType() == trigger::TriggerElectron || v->getObjectType() == trigger::TriggerL1NoIsoEG || v->getObjectType() == trigger::TriggerL1IsoEG )
      {
        histEtaMax = electronEtaMax_;
      }
        else if (v->getObjectType() == trigger::TriggerTau || v->getObjectType() == trigger::TriggerL1TauJet )
      {
        histEtaMax = tauEtaMax_;
      }
      else if (v->getObjectType() == trigger::TriggerJet || v->getObjectType() == trigger::TriggerL1CenJet || v->getObjectType() == trigger::TriggerL1ForJet )
      {
        histEtaMax = jetEtaMax_; 
      }
        else if (v->getObjectType() == trigger::TriggerBJet)
      {
        histEtaMax = bjetEtaMax_;
      }
      else if (v->getObjectType() == trigger::TriggerMET || v->getObjectType() == trigger::TriggerL1ETM )
      {
        histEtaMax = metEtaMax_; 
      }
        else if (v->getObjectType() == trigger::TriggerPhoton)
      {
        histEtaMax = photonEtaMax_; 
      }
      else if (v->getObjectType() == trigger::TriggerTrack)
      {
        histEtaMax = trackEtaMax_; 
      }

      TString pathfolder = dirname_ + TString("/") + pathName;
      dbe_->setCurrentFolder(pathfolder.Data());

      NOn =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);


       histoname = labelname+"_NOff";
       title = labelname+" N Off";
       NOff =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
       
       histoname = labelname+"_NL1";
       title = labelname+" N L1";
       NL1 =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
       
       histoname = labelname+"_NL1On";
       title = labelname+" N L1On";
       NL1On =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
       
       histoname = labelname+"_NL1Off";
       title = labelname+" N L1Off";
       NL1Off =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
       
       histoname = labelname+"_NOnOff";
       title = labelname+" N OnOff";
       NOnOff =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
       
       histoname = labelname+"_onEtOn";
       title = labelname+" onE_t online";
       onEtOn =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
       
       histoname = labelname+"_onOneOverEtOn";
       title = labelname+" 1 / onE_t online";
       onOneOverEtOn =  dbe->book1D(histoname.c_str(), title.c_str(),nBinsOneOverEt_, 0, 0.1);
       onOneOverEtOn->setAxisTitle("HLT 1/Et [1/GeV]");
       
       histoname = labelname+"_offEtOff";
       title = labelname+" offE_t offline";
       offEtOff =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
       
       histoname = labelname+"_l1EtL1";
       title = labelname+" l1E_t L1";
       l1EtL1 =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
       
       histoname = labelname+"_onEtaonPhiOn";
       title = labelname+" on#eta vs on#phi online";
       onEtavsonPhiOn =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
       
       histoname = labelname+"_offEtaoffPhiOff";
       title = labelname+" off#eta vs off#phi offline";
       offEtavsoffPhiOff =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
       
       histoname = labelname+"_l1Etal1PhiL1";
       title = labelname+" l1#eta vs l1#phi L1";
       l1Etavsl1PhiL1 =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
       
       histoname = labelname+"_l1EtL1On";
       title = labelname+" l1E_t L1+online";
       l1EtL1On =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
       
       histoname = labelname+"_offEtL1Off";
       title = labelname+" offE_t L1+offline";
       offEtL1Off =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
       
       histoname = labelname+"_offEtOnOff";
       title = labelname+" offE_t online+offline";
       offEtOnOff =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
       
       histoname = labelname+"_l1Etal1PhiL1On";
       title = labelname+" l1#eta vs l1#phi L1+online";
       l1Etavsl1PhiL1On =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
       
       histoname = labelname+"_offEtaoffPhiL1Off";
       title = labelname+" off#eta vs off#phi L1+offline";
       offEtavsoffPhiL1Off =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
       
       histoname = labelname+"_offEtaoffPhiOnOff";
       title = labelname+" off#eta vs off#phi online+offline";
       offEtavsoffPhiOnOff =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
       
       if (useUM) {

     histoname = labelname+"_NL1OnUM";
     title = labelname+" N L1OnUM";
     NL1OnUM =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
     
     histoname = labelname+"_NL1OffUM";
     title = labelname+" N L1OffUM";
     NL1OffUM =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
     
     histoname = labelname+"_NOnOffUM";
     title = labelname+" N OnOffUM";
     NOnOffUM =  dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
     
     histoname = labelname+"_l1EtL1OnUM";
     title = labelname+" l1E_t L1+onlineUM";
     l1EtL1OnUM =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
     
     histoname = labelname+"_offEtL1OffUM";
     title = labelname+" offE_t L1+offlineUM";
     offEtL1OffUM =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
     
     histoname = labelname+"_offEtOnOffUM";
     title = labelname+" offE_t online+offlineUM";
     offEtOnOffUM =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
     
     histoname = labelname+"_l1Etal1PhiL1OnUM";
     title = labelname+" l1#eta vs l1#phi L1+onlineUM";
     l1Etavsl1PhiL1OnUM =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
     
     histoname = labelname+"_offEtaoffPhiL1OffUM";
     title = labelname+" off#eta vs off#phi L1+offlineUM";
     offEtavsoffPhiL1OffUM =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
     
     histoname = labelname+"_offEtaoffPhiOnOffUM";
     title = labelname+" off#eta vs off#phi online+offlineUM";
     offEtavsoffPhiOnOffUM =  dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
     
       }    
       
       histoname = labelname+"_l1DRL1On";
       title = labelname+" l1DR L1+online";
       l1DRL1On =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_); 
       
       histoname = labelname+"_offDRL1Off";
       title = labelname+" offDR L1+offline";
       offDRL1Off =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_);
       
       histoname = labelname+"_offDROnOff";
       title = labelname+" offDR online+offline";
       offDROnOff =  dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_); 


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

    }  // end for hltPath

    // bjk here
//     // HLT_Any
//     // book Count vs LS
//     dbe_->setCurrentFolder(pathsIndividualHLTPathsPerLSFolder_.c_str());
//     MonitorElement* tempME = dbe_->book1D("HLT_Any_count_per_LS", 
//                            "HLT_Any count per LS",
//                            nLS_, 0,nLS_);
//     tempME->setAxisTitle("Luminosity Section");

  } // end if(1) dummy

 if(!doCombineRuns_) fIsSetup = true;

 return;

}

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

{

  LogDebug("FourVectorHLTOffline") << "cleanDRMatchSet(mmset& tempSet) " << "size of the set (before CLEANING) = " << tempSet.size() << " maps." << endl;

  if(tempSet.size() < 2) return;

  if(tempSet.size() > 10) {

    LogDebug("FourVectorHLTOffline") << "size of the set is too large.  It will be truncated to 10." << endl;
    mmset::iterator it = tempSet.begin();
    for (int i=0;i<10;i++) {    it++; }
    tempSet.erase( it, tempSet.end());
    LogDebug("FourVectorHLTOffline") << "size of the set is now = " << tempSet.size() << " maps." << endl;

  }
 
  bool cleanedOneMap = false;
 
  // cleaning needed if the set has at least two maps

  while(! cleanedOneMap && tempSet.size() > 1) {

    cleanedOneMap=false;

    //LogTrace("FourVectorHLTOffline") << "cleaning: size of the set  = " << tempSet.size() << " maps." << endl;

    int imap = 0;
    for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ ) {

      fimmap tempMap_j = *setIter_i;

      //LogTrace("FourVectorHLTOffline") << " map " << imap << endl;
      //LogTrace("FourVectorHLTOffline") << " --------" << endl;

      for (fimmap::iterator it = tempMap_j.begin(); it != tempMap_j.end(); ++it) {

        //LogTrace("FourVectorHLTOffline") << " " <<   (*it).first << " :  " << (*it).second << endl;

      }

      imap++;

    }

    // loop i
    for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ ) {
     
      fimmap tempMap_i = *setIter_i;
      fimmap::iterator it = tempMap_i.begin();
      int topValue = (*it).second;
      //LogTrace("FourVectorHLTOffline") << " topValue = " << topValue << endl;
  
      
      mmset::iterator tempIter_i = setIter_i;
  
      // from all the other maps, clean entries that have mapped value "topValue"
      // loop j
      mmset::iterator setIter_j = ++tempIter_i;
      while ( setIter_j != tempSet.end( ) ) {
  
        fimmap tempMap_j = *setIter_j;
        //LogTrace("FourVectorHLTOffline") << "  size of the map  = " << tempMap_j.size() << endl;
  
        fimmap::iterator it = tempMap_j.begin();
        while ( it != tempMap_j.end() ) {
  
          if(topValue == (*it).second) {
            
            //LogTrace("FourVectorHLTOffline") << "   Ridding map of a doubly-matched object." << endl;
            fimmap::iterator tempIt = it;
            ++it; //no longer points to item that is going away
            tempMap_j.erase(tempIt);
            cleanedOneMap = true;
  
          } else {
            ++it;
          } // end if

        } //end while
  
        if(cleanedOneMap) {
          
          //remove the old map from the set
          mmset::iterator tempIt = setIter_j;
          ++setIter_j; //no longer points to item that is going away
          tempSet.erase(tempIt);
  
          // insert in the set the new map if it is not an empty map
          if(! tempMap_j.empty()) tempSet.insert(tempMap_j);
  
          break; // break from loop j
  
       } else {
         ++setIter_j;
       } // end if

  
      }// end while j
  
      if(cleanedOneMap) break; // break from loop i

    } // end loop i

    if(cleanedOneMap) { 

      // continue cleaning (in while loop)
      // but reset flag first
      cleanedOneMap=false;
      continue; 

    }
    else {

      // finished cleaing (break from while loop)
      break; 

    }

  } // end while

  //LogTrace("FourVectorHLTOffline") << "cleaned: size of the set  = " << tempSet.size() << " maps." << endl;
  int jmap = 0;

  for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ ) 
  {

    fimmap tempMap_j = *setIter_i;

    //LogTrace("FourVectorHLTOffline") << " map " << jmap << endl;
    //LogTrace("FourVectorHLTOffline") << " --------" << endl;

    for (fimmap::iterator it = tempMap_j.begin(); it != tempMap_j.end(); ++it) {

        //LogTrace("FourVectorHLTOffline") << " " <<   (*it).first << " :  " << (*it).second << endl;
      
    }

    jmap++;

  } // end for

  return;

}

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.

{

 LogTrace("FourVectorHLTOffline") << " countHLTGroupBXHitsEndLumiBlock() lumiSection number " << lumi << endl;

   TH2F * hist_2d_bx = ME_HLT_BX->getTH2F();

   for (std::vector<std::pair<std::string, vector<int> > >::iterator ip = fPathBxTempCountPair.begin(); ip != fPathBxTempCountPair.end(); ++ip) {
  
    // get the path and its previous count
    std::string pathname = ip->first;  
    vector<int> prevCount = ip->second;  

    // vector of 5 zeros
    vector<int> currCount (5,0);
    vector<int> diffCount (5,0);
    
    // get the current count of path up to now
    int pathBin = hist_2d_bx->GetYaxis()->FindBin(pathname.c_str());      

    if(pathBin > hist_2d_bx->GetNbinsY()) {
      
      LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
      continue;

    }

    for (unsigned int b =0;b<currCount.size();b++) { 

      int bxOffset = b-2;
      int bunch = referenceBX_+bxOffset;
      if(bunch < 1) bunch += Nbx_ ;
      int bxBin = bunch +1; // add one to get the right bin

      
      currCount[b] = int(hist_2d_bx->GetBinContent(bxBin, pathBin));  // add one to get the right bin

      LogTrace("FourVectorHLTOffline") << "currCount = " << currCount[b] << endl;

      // count due to prev lumi sec is a difference bw current and previous
      diffCount[b] = currCount[b] - prevCount[b];

      LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << "  path " << pathname << "bxOffset = " << bxOffset << "  count = " << diffCount[b] <<  endl;

    } // end for bx b

    // set the counter in the pair to current count
    ip->second = currCount;  

   // fill the 2D Group paths' BX count per LS, using currCount
   LogTrace("FourVectorHLTOffline")  << "Find " << pathname << endl;

   //check if the path is in this group
   for (unsigned int j=0;j<fGroupNamePathsPair.size();j++) { 

      bool isMember = false;

      LogTrace("FourVectorHLTOffline")  << " ---- Group " << fGroupNamePathsPair[j].first << endl;

      // decide if pathname is member of this group
      for (unsigned int k = 0; k<(fGroupNamePathsPair[j].second).size();k++) {

        LogTrace("FourVectorHLTOffline")  << " comparing to " <<  fGroupNamePathsPair[j].second[k] << endl; 

        if(fGroupNamePathsPair[j].second[k] == pathname) {

          isMember = true;
          break;

        }

      } // end for k

      if(!isMember) {
      
      LogTrace("FourVectorHLTOffline")  << "Could not find a group to which the path belongs, path = " << pathname << "    group = " << fGroupNamePathsPair[j].first << endl;
      continue;

      }

      MonitorElement* ME_2d = v_ME_Total_BX[j];

      if (! ME_2d) {

        LogDebug("FourVectorHLTOffline") << " cannot find ME_2d for group " << fGroupNamePathsPair[j].first  <<  endl;
        continue;

      }

      vector<int> updatedLumiCount(5,0);

      float entireBXWindowUpdatedLumiCount = 0;
      
      TH2F* hist_All = ME_2d->getTH2F();

      for (unsigned int b = 0; b<diffCount.size();b++) {

        // find the bin
        int binNumber = b+1; // add one to get right bin

        // update  the bin content  (must do that since events don't ncessarily come in the order
        int currentLumiCount = int(hist_All->GetBinContent(lumi+1,binNumber));
        updatedLumiCount[b] = currentLumiCount + diffCount[b];
        hist_All->SetBinContent(lumi+1,binNumber,updatedLumiCount[b]);

        entireBXWindowUpdatedLumiCount += updatedLumiCount[b];
        
      } // end for bx b

      MonitorElement* ME_2d_Norm = v_ME_Total_BX_Norm[j];

      if (! ME_2d_Norm) {

        LogDebug("FourVectorHLTOffline") << " cannot find ME_2d_Norm for group " << fGroupNamePathsPair[j].first  <<  endl;
        continue;

      }

      TH2F* hist_All_Norm = ME_2d_Norm->getTH2F();

      for (unsigned int b = 0; b<diffCount.size();b++) {

        // find the bin
        int binNumber = b+1; // add one to get right bin

        // update  the bin content  but normalized to the whole columb (BX windw +/- 2)
        if(entireBXWindowUpdatedLumiCount != 0)
         hist_All_Norm->SetBinContent(lumi+1,binNumber,float(updatedLumiCount[b])/entireBXWindowUpdatedLumiCount);

      } // end for bx b
    
    } // end for group j
    
  } // end for ip

}

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

{

 LogTrace("FourVectorHLTOffline") << " countHLTGroupHitsEndLumiBlock() lumiSection number " << lumi << endl;
 for(unsigned int i=0; i<fGroupNamePathsPair.size(); i++){

   // get the count of path up to now
   string fullPathToME = "HLT/FourVector/PathsSummary/HLT_" + fGroupNamePathsPair[i].first + "_Pass_Any";
   MonitorElement* ME_1d = dbe_->get(fullPathToME);

   if(! ME_1d) {

     LogTrace("FourVectorHLTOffline") << " could not find 1d matrix " << fullPathToME << endl;

     continue;

   }

   LogTrace("FourVectorHLTOffline") << " Looking in histogram "  << fullPathToME << endl;

   TH1F * hist_1d = ME_1d->getTH1F();

   for (std::vector<std::pair<std::string, float> >::iterator ip = fGroupTempCountPair.begin(); ip != fGroupTempCountPair.end(); ++ip) {
  
    // get the path and its previous count
    string pathname = ip->first;  
    float prevCount = ip->second;  

    string binLabel = "HLT_"+pathname+"_Any";
    
    LogTrace("FourVectorHLTOffline") << " Looking for binLabel = " << binLabel <<  endl;
    // get the current count of path up to now
    int pathBin = hist_1d->GetXaxis()->FindBin(binLabel.c_str());      

    LogTrace("FourVectorHLTOffline") << " pathBin = " << pathBin <<  "  out of histogram total number of bins " << hist_1d->GetNbinsX() <<  endl;
    if(pathBin == -1) {
      
      LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
      continue;

    }

    float currCount = hist_1d->GetBinContent(pathBin)/LSsize_;

    // count due to prev lumi sec is a difference bw current and previous
    float diffCount = currCount - prevCount;

    LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << "  path " << pathname << "  count " << diffCount <<  endl;

    // set the counter in the pair to current count
    ip->second = currCount;  


    // fill the 1D individual path count per LS
    string fullPathToME_count = pathsSummaryHLTPathsPerLSFolder_ +"HLT_" + pathname + "_Total_LS";
    MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
    if ( ME_1d) { 

      // update  the bin content  (must do that since events don't ncessarily come in the order
      float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
      float updatedLumiCount = currentLumiCount + diffCount;
      ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);

    }
    else {

      LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count  <<  endl;

    }

   } // end for ip

 } // end for i

}

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

{

 LogTrace("FourVectorHLTOffline") << " countHLTGroupL1HitsEndLumiBlock() lumiSection number " << lumi << endl;

 for(unsigned int i=0; i<fGroupNamePathsPair.size(); i++){

   // get the count of path up to now
   string fullPathToME = "HLT/FourVector/PathsSummary/HLT_" + fGroupNamePathsPair[i].first+ "_Pass_Any";
   MonitorElement* ME_1d = dbe_->get(fullPathToME);

   if(! ME_1d) {

     LogTrace("FourVectorHLTOffline") << " could not find 1d matrix " << fullPathToME << endl;

     continue;

   }

   LogTrace("FourVectorHLTOffline") << " Looking in histogram "  << fullPathToME << endl;

   TH1F * hist_1d = ME_1d->getTH1F();

   for (std::vector<std::pair<std::string, float> >::iterator ip = fGroupL1TempCountPair.begin(); ip != fGroupL1TempCountPair.end(); ++ip) {
  
    // get the path and its previous count
    string pathname = ip->first;  
    float prevCount = ip->second;  

    string binLabel = "HLT_"+pathname+"_L1_Any";
    
    LogTrace("FourVectorHLTOffline") << " Looking for binLabel = " << binLabel <<  endl;
    // get the current count of path up to now
    int pathBin = hist_1d->GetXaxis()->FindBin(binLabel.c_str());      

    LogTrace("FourVectorHLTOffline") << " pathBin = " << pathBin <<  "  out of histogram total number of bins " << hist_1d->GetNbinsX() <<  endl;
    if(pathBin == -1) {
      
      LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
      continue;

    }

    float currCount = hist_1d->GetBinContent(pathBin)/LSsize_;

    // count due to prev lumi sec is a difference bw current and previous
    float diffCount = currCount - prevCount;

    LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << "  path " << pathname << "  count " << diffCount <<  endl;

    // set the counter in the pair to current count
    ip->second = currCount;  


    // fill the 1D individual path count per LS
    string fullPathToME_count = pathsSummaryHLTPathsPerLSFolder_ +"HLT_" + pathname + "_L1_Total_LS";
    MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
    if ( ME_1d) { 
      
      // update  the bin content  (must do that since events don't ncessarily come in the order
      float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
      float updatedLumiCount = currentLumiCount + diffCount;
      ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);
    }
    else {

      LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count  <<  endl;

    }

   } // end for ip

 } // end for i

}

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.

{

   LogTrace("FourVectorHLTOffline") << " countHLTPathHitsEndLumiBlock() lumiSection number " << lumi << endl;
    // get the count of path up to now
   string fullPathToME = "HLT/FourVector/PathsSummary/HLT_All_PassPass";
   MonitorElement* ME_2d = dbe_->get(fullPathToME);

   if(! ME_2d) {

     LogTrace("FourVectorHLTOffline") << " could not fine 2d matrix " << fullPathToME << endl;

     return;

   }

   TH2F * hist_2d = ME_2d->getTH2F();

   for (std::vector<std::pair<std::string, float> >::iterator ip = fPathTempCountPair.begin(); ip != fPathTempCountPair.end(); ++ip) {
  
    // get the path and its previous count
    std::string pathname = ip->first;  
    float prevCount = ip->second;  
    
    // get the current count of path up to now
    float pathBin = hist_2d->GetXaxis()->FindBin(pathname.c_str());      

    if(pathBin > hist_2d->GetNbinsX()) {
      
      LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
      continue;

    }

    float currCount = hist_2d->GetBinContent(pathBin, pathBin)/LSsize_;

    // count due to prev lumi sec is a difference bw current and previous
    float diffCount = currCount - prevCount;

    LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << "  path " << pathname << "  count " << diffCount <<  endl;

    // set the counter in the pair to current count
    ip->second = currCount;  

    // fill the 2D All paths' count per LS
    if ( ME_HLTAll_LS) {

      TH2F* hist_All = ME_HLTAll_LS->getTH2F();

      // find the bin
      int pathBinNumber = hist_All->GetYaxis()->FindBin(pathname.c_str());
      
      // update  the bin content  (must do that since events don't ncessarily come in the order
      float currentLumiCount = hist_All->GetBinContent(lumi+1,pathBinNumber);
      float updatedLumiCount = currentLumiCount + diffCount;
      hist_All->SetBinContent(lumi+1,pathBinNumber,updatedLumiCount);
    
    }
    else {

      LogDebug("FourVectorHLTOffline") << " cannot find ME_HLTAll_LS" <<  endl;

    }
    
//     for (unsigned int i=0 ; i< v_ME_HLTAll_LS.size(); i++) {  
      
//       MonitorElement* tempME = v_ME_HLTAll_LS[i];

//       if (tempME && tempME->getName().find(pathname) != std::string::npos) {
  
//         TH1F* hist_All = tempME->getTH1F();
  
// //         // find the bin
// //         int pathBinNumber = hist_All->GetYaxis()->FindBin(pathname.c_str());
// //         // update  the bin content  (must do that since events don't ncessarily come in the order
//         float currentLumiCount = hist_All->GetBinContent(lumi+1);
//         float updatedLumiCount = currentLumiCount + diffCount;
//         hist_All->SetBinContent(lumi+1,updatedLumiCount);
      
//       }
//       else {
  
//         LogDebug("FourVectorHLTOffline") << " cannot find tempME " <<  endl;
  
//       }

//     }


    // bjk here
//     ///////////////////////////////////////////
//     // fill the 1D individual path count per LS
//     ///////////////////////////////////////////
//     string fullPathToME_count = pathsIndividualHLTPathsPerLSFolder_ + pathname + "_count_per_LS";
//     MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
//     if ( ME_1d) { 

//       // update  the bin content  (must do that since events don't ncessarily come in the order
//       float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
//       float updatedLumiCount = currentLumiCount + diffCount;
//       ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);

//     }
//     else {

//       LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count  <<  endl;

//     }

  } // end for ip

}

void FourVectorHLTOffline::endJob ( void  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 753 of file FourVectorHLTOffline.cc.

References nev_.

{
   LogInfo("FourVectorHLTOffline") << "analyzed " << nev_ << " events";
   return;
}

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

{

   int lumi = int(lumiSeg.id().luminosityBlock());
   LogTrace("FourVectorHLTOffline") << " end lumiSection number " << lumi << endl;

   //  countHLTPathHitsEndLumiBlock(lumi);
  countHLTGroupHitsEndLumiBlock(lumi);
  countHLTGroupL1HitsEndLumiBlock(lumi);

  //  countHLTGroupBXHitsEndLumiBlock(lumi);

}

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.

{

  LogDebug("FourVectorHLTOffline") << "endRun, run " << run.id();

}

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

                                                                             {


 string fullPathToME; 

 //for (unsigned int mi=0;mi<fGroupName.size();mi++) {
  for (unsigned int mi=0;mi<fGroupNamePathsPair.size();mi++) {


  fullPathToME = "HLT/FourVector/PathsSummary/HLT_"+fGroupNamePathsPair[mi].first+"_PassPass";
  MonitorElement* ME_2d = dbe_->get(fullPathToME);
  fullPathToME = "HLT/FourVector/PathsSummary/HLT_"+fGroupNamePathsPair[mi].first+"_Pass_Any";
  MonitorElement* ME_1d = dbe_->get(fullPathToME);
  if(!ME_2d || !ME_1d) {  

    LogTrace("FourVectorHLTOffline") << " ME not valid although I gave full path" << endl;
    continue;

  }

  TH2F * hist_2d = ME_2d->getTH2F();
  TH1F * hist_1d = ME_1d->getTH1F();

  // Fill HLTPassed Matrix bin (i,j) = (Any,Any)
  // --------------------------------------------------------
  int anyBinNumber = hist_2d->GetXaxis()->FindBin("HLT_Any");      

  string groupBinLabel = "HLT_"+fGroupNamePathsPair[mi].first+"_Any";
  int groupBinNumber = hist_2d->GetXaxis()->FindBin(groupBinLabel.c_str()); 

  // any trigger accepted
  if(fTriggerResults->accept()){

    hist_2d->Fill(anyBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter
    hist_1d->Fill(anyBinNumber-1);//binNumber1 = 0 = first filter

  }

  bool groupPassed = false;
  //bool groupL1Passed = false;

  // Main loop over paths
  // --------------------

  //for (int i=1; i< hist_2d->GetNbinsX();i++) 
  for (unsigned int i=0; i< fGroupNamePathsPair[mi].second.size(); i++)
  { 

    //string hltPathName =  hist_2d->GetXaxis()->GetBinLabel(i);
    string hltPathName =  fGroupNamePathsPair[mi].second[i];

    // check if this is hlt path name
    //unsigned int pathByIndex = triggerNames.triggerIndex(hltPathName);
    unsigned int pathByIndex = triggerNames.triggerIndex(fGroupNamePathsPair[mi].second[i]);
    if(pathByIndex >= fTriggerResults->size() ) continue;

    // check if its L1 passed
    // comment out below but set groupL1Passed to true always
    //if(hasL1Passed(hltPathName,triggerNames)) groupL1Passed = true;
    //groupL1Passed = true;

    // Fill HLTPassed Matrix and HLTPassFail Matrix
    // --------------------------------------------------------

    if(fTriggerResults->accept(pathByIndex)){

      groupPassed = true;
      //groupL1Passed = true;

      hist_2d->Fill(i,anyBinNumber-1);//binNumber1 = 0 = first filter
      hist_2d->Fill(anyBinNumber-1,i);//binNumber1 = 0 = first filter

      hist_2d->Fill(i,groupBinNumber-1);//binNumber1 = 0 = first filter
      hist_2d->Fill(groupBinNumber-1,i);//binNumber1 = 0 = first filter
     
      hist_1d->Fill(i);//binNumber1 = 0 = first filter


      //for (int j=1; j< hist_2d->GetNbinsY();j++) 
      for (unsigned int j=0; j< fGroupNamePathsPair[mi].second.size(); j++)
      { 

        string crossHltPathName =  fGroupNamePathsPair[mi].second[j];
  
        //unsigned int crosspathByIndex = triggerNames.triggerIndex(hist_2d->GetXaxis()->GetBinLabel(j));
        //unsigned int crosspathByIndex = triggerNames.triggerIndex(crossHltPathName);
        unsigned int crosspathByIndex = triggerNames.triggerIndex(fGroupNamePathsPair[mi].second[j]);

        if(crosspathByIndex >= fTriggerResults->size() ) continue;
  
        if(fTriggerResults->accept(crosspathByIndex)){
  
          hist_2d->Fill(i,j);//binNumber1 = 0 = first filter
  
        } // end if j path passed
  
      } // end for j 
  
    } // end if i passed
    

  } // end for i

  if(groupPassed) {
    
    hist_1d->Fill(groupBinNumber-1);//binNumber1 = 0 = first filter
    hist_1d->Fill(groupBinNumber-2);//binNumber1 = 0 = first filter -> Fill L1group as well
    hist_2d->Fill(groupBinNumber-1,groupBinNumber-1);//binNumber1 = 0 = first filter
    hist_2d->Fill(anyBinNumber-1,groupBinNumber-1);//binNumber1 = 0 = first filter
    hist_2d->Fill(groupBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter

  }

  /*
  string groupL1BinLabel = "HLT_"+fGroupNamePathsPair[mi].first+"_L1_Any";
  int groupL1BinNumber = hist_2d->GetXaxis()->FindBin(groupL1BinLabel.c_str());      

  if(groupL1Passed) hist_1d->Fill(groupL1BinNumber-1);//binNumber1 = 0 = first filter
  */
 } // end for mi

}

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

{
  
  std::string pathname = name;
  //cout << "----------------------------------------------" << endl;
  //cout << pathname << endl;

  //remove "L1" substr
  if(pathname.find("L1") != std::string::npos) pathname.replace(pathname.find("L1"),2,"");
  //remove "L2" substr
  if(pathname.find("L2") != std::string::npos) pathname.replace(pathname.find("L2"),2,"");
  //remove "8E29" substr
  if(pathname.find("8E29") != std::string::npos) pathname.replace(pathname.find("8E29"),4,"");

  int digitLocation=0;
  for (unsigned int i=0; i < pathname.length(); i++)
  {
     if (isdigit(pathname.at(i))) {

       digitLocation = i;
       break;

     }
  }

  // get the string from the location of the first digit to the end
  string hltThresholdString = pathname.substr(digitLocation);

  int hltThreshold = 0;

  // get intiger at the begining of the string
  sscanf (hltThresholdString.c_str(),"%d%*s",&hltThreshold);
  //printf ("%s -> %s -> %d\n",pathname.c_str(), hltThresholdString.c_str(), hltThreshold);

  return hltThreshold;

}

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

{

  // find L1 condition for numpath with numpath objecttype 
  // find PSet for L1 global seed for numpath, 
  // list module labels for numpath
  string l1pathname = "dummy";

  vector<string> numpathmodules = hltConfig_.moduleLabels(pathname);

  for(vector<string>::iterator numpathmodule = numpathmodules.begin();
  numpathmodule!= numpathmodules.end(); ++numpathmodule ) {

    if (hltConfig_.moduleType(*numpathmodule) == "HLTLevel1GTSeed") {

     l1pathname = *numpathmodule;
     break; 

    }

  } // end for

  return l1pathname;

}

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

{

   int objectType = 0;

     if (pathname.find("MET") != std::string::npos) 
       objectType = trigger::TriggerMET;    
     if (pathname.find("SumET") != std::string::npos || pathname.find("SumEt") != std::string::npos || pathname.find("ETT") != std::string::npos) 
       objectType = trigger::TriggerTET;    
     if (pathname.find("HT") != std::string::npos) 
       objectType = trigger::TriggerTET;    
     if (pathname.find("Jet") != std::string::npos) 
       objectType = trigger::TriggerJet;    
     if (pathname.find("Mu") != std::string::npos)
       objectType = trigger::TriggerMuon;    
     if (pathname.find("Ele") != std::string::npos) 
       objectType = trigger::TriggerElectron;    
     if (pathname.find("Photon") != std::string::npos) 
       objectType = trigger::TriggerPhoton;    
     if (pathname.find("EG") != std::string::npos) 
       objectType = trigger::TriggerPhoton;    
     if (pathname.find("Tau") != std::string::npos) 
       objectType = trigger::TriggerTau;    
     if (pathname.find("IsoTrack") != std::string::npos) 
       objectType = trigger::TriggerTrack;    
     if (pathname.find("BTag") != std::string::npos) 
       objectType = trigger::TriggerBJet;    

   return objectType;
}

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

{
  
  bool rc = false;

  unsigned int pathByIndex = triggerNames.triggerIndex(pathname);
  if(pathByIndex >= fTriggerResults->size() ) return rc; // path is not in the menu

  rc  = fTriggerResults->accept(pathByIndex);

  return rc;

}

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.

{
  
  bool rc = false;
  int l1ModuleIndex = 999;
  // --------------------
  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) { 

    if(v->getPath() == pathname ) l1ModuleIndex = v->getL1ModuleIndex();

  }

  unsigned int pathByIndex = triggerNames.triggerIndex(pathname);
  if(pathByIndex >= fTriggerResults->size() ) return rc; // path is not in the menu

  // get index of the last module that issued the decision
  int lastModule = fTriggerResults->index(pathByIndex);

  // if L1 passed, then it must not be the module that 
  // issued the last decision
  rc = (l1ModuleIndex < lastModule);

  return rc;

}

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

{

  reco::TrackRef gm = muon.globalTrack();
  reco::TrackRef tk = muon.innerTrack();

  // Quality cuts
  // ------------

  // Must have BeamSpot for the 1st qualityCut
  if(!fBeamSpotHandle.isValid()) return 0;

  double dxy = gm->dxy(fBeamSpotHandle->position());
  double normalizedChi2 = gm->normalizedChi2(); 
  int trackerHits = tk->hitPattern().numberOfValidTrackerHits();
  int pixelHits = tk->hitPattern().numberOfValidPixelHits();
  int muonHits = gm->hitPattern().numberOfValidMuonHits();
  int nMatches = muon.numberOfMatches();

  if (fabs(dxy)>dxyCut_) {return 0;}
  //               if(plotHistograms_){ h1_["hNormChi2"]->Fill(normalizedChi2);}
  if (normalizedChi2>normalizedChi2Cut_) {return 0;}
  //               if(plotHistograms_){ h1_["hNHits"]->Fill(trackerHits);}
  if (trackerHits<trackerHitsCut_) {return 0;}
  //               if(plotHistograms_){ h1_["hNMuonHits"]->Fill(muonHits);}
  if (pixelHits<pixelHitsCut_) {return 0;}
  //               if(plotHistograms_){ h1_["hNPixelHits"]->Fill(pixelHits);}
  if (muonHits<muonHitsCut_) {return 0;}
  //               if(plotHistograms_){ h1_["hTracker"]->Fill(mu.isTrackerMuon());}
  if (!muon.isTrackerMuon()) {return 0;}
  //               if(plotHistograms_){ h1_["hNMatches"]->Fill(nMatches);}
  if (nMatches<nMatchesCut_) {return 0;}

  return true;

}

string FourVectorHLTOffline::removeVersions ( std::string  histVersion )

private

Definition at line 2625 of file FourVectorHLTOffline.cc.

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

Referenced by beginRun().

                                                                  {
   for (int ii = 100; ii >= 0; ii--) {
     string ver = "_v";
     string version ="";
     stringstream ss;
     ss << ver << ii;
     ss >> version;
     
     size_t pos = histVersion.find(version);
     if (pos != std::string::npos)
       histVersion.erase(pos,version.size());
     
   }
   
   return histVersion;
 }

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(), getDQMSummary::iter, edm::HandleBase::provenance(), recHitsEBToken, recHitsEEToken, sigmaIetaIetaEB_, sigmaIetaIetaEC_, sigmaIetaIetaSpikesEB_, and sigmaIetaIetaSpikesEC_.

Referenced by analyze().

{

  // for every event, first clear vector of selected objects
  fSelectedElectrons->clear();




  if(eleHandle.isValid()) { 

    for( reco::GsfElectronCollection::const_iterator iter = eleHandle->begin(), iend = eleHandle->end(); iter != iend; ++iter )
    {
      
      edm::Handle< EcalRecHitCollection > pEBRecHits;
      iEvent.getByToken( recHitsEBToken, pEBRecHits );

      edm::Handle< EcalRecHitCollection > pEERecHits;
      iEvent.getByToken( recHitsEEToken, pEERecHits );

      if(pEBRecHits.isValid() && pEERecHits.isValid()) {
      
        EcalClusterLazyTools lazyTool(iEvent, iSetup, recHitsEBToken, recHitsEEToken); 
        const reco::CaloCluster* bc = iter->superCluster()->seed().get(); // get the basic cluster
      
        float eleMaxOver3x3 = ( lazyTool.eMax(*bc) / lazyTool.e3x3(*bc)  );

        if(eleMaxOver3x3 > eleMaxOver3x3_) continue;

      }

      // Only ecalDriven electrons
      if(! iter->ecalDriven() ) continue;


      // Barrel 
      if(iter->isEB()) {

        if (
                  iter->dr03TkSumPt()         < dr03TkSumPtEB_ && 
                  iter->dr04EcalRecHitSumEt() < dr04EcalRecHitSumEtEB_ && 
                  iter->dr04HcalTowerSumEt()  < dr04HcalTowerSumEtEB_ &&
                  iter->hadronicOverEm()      < hadronicOverEmEB_ &&
                  fabs(iter->deltaPhiSuperClusterTrackAtVtx()) < deltaPhiSuperClusterTrackAtVtxEB_ && 
                  fabs(iter->deltaEtaSuperClusterTrackAtVtx()) < deltaEtaSuperClusterTrackAtVtxEB_ &&
                  iter->sigmaIetaIeta() < sigmaIetaIetaEB_ &&
          //spikes
                  iter->sigmaIetaIeta() > sigmaIetaIetaSpikesEB_
        ) {

            fSelectedElectrons->push_back(*iter);

        }

      } // end if

      // EndCap
      else if(iter->isEE()) {
        if (
                  iter->dr03TkSumPt()         < dr03TkSumPtEC_ && 
                  iter->dr04EcalRecHitSumEt() < dr04EcalRecHitSumEtEC_ && 
                  iter->dr04HcalTowerSumEt()  < dr04HcalTowerSumEtEC_ && 
                  iter->hadronicOverEm()      < hadronicOverEmEC_ && 
                  fabs(iter->deltaPhiSuperClusterTrackAtVtx()) < deltaPhiSuperClusterTrackAtVtxEC_ && 
                  fabs(iter->deltaEtaSuperClusterTrackAtVtx()) < deltaEtaSuperClusterTrackAtVtxEC_ && 
                  iter->sigmaIetaIeta() < sigmaIetaIetaEC_ && 
          //spikes
                  iter->sigmaIetaIeta() > sigmaIetaIetaSpikesEC_
        ) {

            fSelectedElectrons->push_back(*iter);

          }

      } // end else if


    } // end for
  
    edm::Handle<reco::GsfElectronCollection> localSelElectronsHandle(fSelectedElectrons,eleHandle.provenance());
    fSelElectronsHandle = localSelElectronsHandle;

  } // end if


}

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(), getDQMSummary::iter, jetID, n90Jet_, and edm::HandleBase::provenance().

Referenced by analyze().

{
  // for every event, first clear vector of selected objects
  fSelectedJets->clear();

  if(jetHandle.isValid()) { 

    for( reco::CaloJetCollection::const_iterator iter = jetHandle->begin(), iend = jetHandle->end(); iter != iend; ++iter )
    {

       jetID->calculate(iEvent, *iter);
       if (iter->emEnergyFraction() > emEnergyFractionJet_ &&
           jetID->fHPD() < fHPDJet_ &&
           iter->n90() >= n90Jet_ 
           ){ 

                fSelectedJets->push_back(*iter);
              
            }

    } // end for
  
    edm::Handle<reco::CaloJetCollection> localSelJetsHandle(fSelectedJets,jetHandle.provenance());
    fSelJetsHandle = localSelJetsHandle;

  } // end if


}

void FourVectorHLTOffline::selectMet ( const edm::Handle< reco::CaloMETCollection > &  metHandle )

private

Definition at line 2482 of file FourVectorHLTOffline.cc.

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

Referenced by analyze().

{
  // for every event, first clear vector of selected objects
  fSelectedMet->clear();

  if(metHandle.isValid()) { 

    for( reco::CaloMETCollection::const_iterator iter = metHandle->begin(), iend = metHandle->end(); iter != iend; ++iter )
    {

      fSelectedMet->push_back(*iter);

    } // end for
  
    edm::Handle<reco::CaloMETCollection> localSelMetHandle(fSelectedMet,metHandle.provenance());
    fSelMetHandle = localSelMetHandle;

  } // end if


}

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(), getDQMSummary::iter, edm::HandleBase::provenance(), and muon::TrackerMuonArbitrated.

Referenced by analyze().

{
  // for every event, first clear vector of selected objects
  fSelectedMuons->clear();

  if(muonHandle.isValid()) { 

    for( reco::MuonCollection::const_iterator iter = muonHandle->begin(), iend = muonHandle->end(); iter != iend; ++iter )
    {

       if(isGoodMuon(*iter, muon::GlobalMuonPromptTight) && 
          isGoodMuon(*iter, muon::TrackerMuonArbitrated))
       {
            if(isVBTFMuon(*iter)) fSelectedMuons->push_back(*iter);
       }
   } // end for
  
    edm::Handle<reco::MuonCollection> localSelMuonsHandle(fSelectedMuons,muonHandle.provenance());
    fSelMuonsHandle = localSelMuonsHandle;

  } // end if


}

void FourVectorHLTOffline::selectPhotons ( const edm::Handle< reco::PhotonCollection > &  phoHandle )

private

Definition at line 2420 of file FourVectorHLTOffline.cc.

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

Referenced by analyze().

{
  // for every event, first clear vector of selected objects
  fSelectedPhotons->clear();

  if(phoHandle.isValid()) { 

    for( reco::PhotonCollection::const_iterator iter = phoHandle->begin(), iend = phoHandle->end(); iter != iend; ++iter )
    {

      if( 

          //spikes
                  iter->sigmaIetaIeta() > 0.002  &&
          iter->maxEnergyXtal() / iter->e3x3() < 0.9

        ) {

          fSelectedPhotons->push_back(*iter);

      }  // end if

    } // end for
  
    edm::Handle<reco::PhotonCollection> localSelPhotonsHandle(fSelectedPhotons,phoHandle.provenance());
    fSelPhotonsHandle = localSelPhotonsHandle;

  } // end if


}

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

{
  // for every event, first clear vector of selected objects
  fSelectedTaus->clear();

  //first read the tau collection
  edm::Handle<reco::PFTauCollection> tauHandle;  
  iEvent.getByToken(hpsPFTauProdToken,tauHandle);

  //Now access a discriminator and see if it passed the tag
  edm::Handle<reco::PFTauDiscriminator> dscrmt1H;
  iEvent.getByToken(tauDscrmtr1Token,dscrmt1H);
  edm::Handle<reco::PFTauDiscriminator> dscrmt2H;
  iEvent.getByToken(tauDscrmtr2Token,dscrmt2H);
  edm::Handle<reco::PFTauDiscriminator> dscrmt3H;
  iEvent.getByToken(tauDscrmtr3Token,dscrmt3H);

  if(tauHandle.isValid() && dscrmt1H.isValid() && dscrmt2H.isValid() && dscrmt3H.isValid()) { 

    for(unsigned int i=0;i<tauHandle->size();++i) {

        //create a ref to the PF Tau 
        reco::PFTauRef pfTauRef(tauHandle,i);

        float outputDiscmnt1 = (*dscrmt1H)[pfTauRef]; // this should be >0.5 to pass
        float outputDiscmnt2 = (*dscrmt2H)[pfTauRef]; // this should be >0.5 to pass
        float outputDiscmnt3 = (*dscrmt3H)[pfTauRef]; // this should be >0.5 to pass

        if(outputDiscmnt1>0.5 && outputDiscmnt2>0.5 && outputDiscmnt3 >0.5) {

          fSelectedTaus->push_back((*tauHandle)[i]);

        }

    } // end for

  
    edm::Handle<reco::PFTauCollection> localSelTauHandle(fSelectedTaus,tauHandle.provenance());
    fSelTausHandle = localSelTauHandle;

  } // end if

}

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

{

  //pathsSummaryFolder_ = TString("HLT/FourVector/PathsSummary/");
  //dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());
  dbe_->setCurrentFolder(pathsSummaryFolder_);

  // setup HLT bx plot
  unsigned int npaths = hltPathsDiagonal_.size();

  ME_HLT_BX = dbe_->book2D("HLT_bx",
                         "HLT counts vs Event bx",
                         Nbx_+1, -0.5, Nbx_+1-0.5, npaths, -0.5, npaths-0.5);
  /*
  ME_HLT_CUSTOM_BX = dbe_->book2D("HLT_Custom_bx",
                         "HLT counts vs Event bx",
                         Nbx_+1, -0.5, Nbx_+1-0.5, npaths, -0.5, npaths-0.5);
                         */
  ME_HLT_BX->setAxisTitle("Bunch Crossing");
  //ME_HLT_CUSTOM_BX->setAxisTitle("Bunch Crossing");


  // Set up bin labels on Y axis continuing to cover all npaths
  for(unsigned int i = 0; i < npaths; i++){

  if (ME_HLT_BX)
    ME_HLT_BX->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());
    //ME_HLT_CUSTOM_BX->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());

  }


}

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

{
 
  unsigned int npaths = hltPathsDiagonal_.size();

  //pathsSummaryHLTPathsPerLSFolder_ = TString("HLT/FourVector/PathsSummary/HLT LS/");
  //dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_.c_str());
  dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_);

  ME_HLTAll_LS  = dbe_->book2D("All_count_LS",
                    "All paths per LS ",
                         nLS_, 0, nLS_, npaths+1, -0.5, npaths+1-0.5);
  ME_HLTAll_LS->setAxisTitle("Luminosity Section");

  // Set up bin labels on Y axis continuing to cover all npaths
  for(unsigned int i = 0; i < npaths; i++){
    if (ME_HLTAll_LS)
      ME_HLTAll_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());

  }

  unsigned int i = npaths;

  if (ME_HLTAll_LS)
    ME_HLTAll_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, "HLT_Any");


}

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

                                                                                          {

    //string groupLabelAny = "HLT_"+label+"_Any";
    //paths.push_back(groupLabelAny.c_str());
    paths.push_back("HLT_"+label+"_L1_Any");
    paths.push_back("HLT_"+label+"_Any");
    paths.push_back("HLT_Any");

    string h_name; 
    string h_title; 

    dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());

    MonitorElement* ME = 0;
    MonitorElement* ME_Any = 0;
    MonitorElement* ME_Normalized = 0;
    MonitorElement* ME_Normalized_Any = 0;

    if (label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor") {
      h_name= "HLT_"+label+"_PassPass";
      h_title = "HLT_"+label+"_PassPass (x=Pass, y=Pass)";
      ME = dbe_->book2D(h_name.c_str(), h_title.c_str(),
                    paths.size(), -0.5, paths.size()-0.5, paths.size(), -0.5, paths.size()-0.5);

      h_name= "HLT_"+label+"_Pass_Any";
      h_title = "HLT_"+label+"_Pass (x=Pass, Any=Pass) normalized to HLT_Any Pass";
      ME_Any = dbe_->book1D(h_name.c_str(), h_title.c_str(),
                        paths.size(), -0.5, paths.size()-0.5);
      
      dbe_->setCurrentFolder(pathsSummaryHLTCorrelationsFolder_.c_str());
      h_name= "HLT_"+label+"_PassPass_Normalized";
      h_title = "HLT_"+label+"_PassPass (x=Pass, y=Pass) normalized to xBin=Pass";
      ME_Normalized = dbe_->book2D(h_name.c_str(), h_title.c_str(),
                           paths.size(), -0.5, paths.size()-0.5, paths.size(), -0.5, paths.size()-0.5);
      h_name= "HLT_"+label+"_Pass_Normalized_Any";
      h_title = "HLT_"+label+"_Pass (x=Pass, Any=Pass) normalized to HLT_Any Pass";
      ME_Normalized_Any = dbe_->book1D(h_name.c_str(), h_title.c_str(),
                               paths.size(), -0.5, paths.size()-0.5);
    }

    if (label != "All" && label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor")
    {
      dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_ + label);
      h_name= "HLT_"+label+"_Total_LS";
      h_title = label+" HLT paths total count combined per LS ";
      MonitorElement* ME_Total_LS = dbe_->book1D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_);
      ME_Total_LS->setAxisTitle("LS");

//       for(std::vector<std::string>::iterator i = paths.begin(), e=paths.end(); i!=e; ++i)
//       {
//         h_name= "HLT_"+removeVersions(*i)+"_LS";
//         h_title = removeVersions(*i) + " inside " + label + " HLT paths count per LS ";
//         MonitorElement* ME_Group_LS = dbe_->book1D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_);
//     ME_Group_LS->setAxisTitle("LS");
//     /// add this path to the vector of 2D LS paths
//     v_ME_HLTAll_LS.push_back(ME_Group_LS);
//       }

    }
    
    
//     dbe_->setCurrentFolder(pathsSummaryHLTPathsPerBXFolder_.c_str());
//     h_name= "HLT_"+label+"_BX_LS";
//     h_title = label+" HLT paths total count combined per BX ";
//     MonitorElement* ME_Total_BX = dbe_->book2D(h_name.c_str(), h_title.c_str(),  nLS_, 0, nLS_, 5, -2.5, 2.5);
//     ME_Total_BX->setAxisTitle("LS",1);
//     v_ME_Total_BX.push_back(ME_Total_BX);

//     h_name= "HLT_"+label+"_BX_LS_Norm";
//     h_title = label+" HLT paths total count combined per BX Normalized to LS";
//     MonitorElement* ME_Total_BX_Norm = dbe_->book2D(h_name.c_str(), h_title.c_str(),  nLS_, 0, nLS_, 5, -2.5, 2.5);
//     ME_Total_BX_Norm->setAxisTitle("LS",1);
//     v_ME_Total_BX_Norm.push_back(ME_Total_BX_Norm);

// bjk: These are OK
      if (label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor") {
    for(unsigned int i = 0; i < paths.size(); i++){
  
      if (ME) {
        ME->getTH2F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
        ME->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
      }
      //       ME_Group_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
      if (ME_Normalized){
        ME_Normalized->getTH2F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
        ME_Normalized->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
      }
      if (ME_Normalized_Any)
        ME_Normalized_Any->getTH1F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());

      if (ME_Any)
        ME_Any->getTH1F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
    }
      }
      
}

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