#include <ZCounting.h>

Inheritance diagram for ZCounting:

Public Types
enum	MuonIDTypes { NoneID, LooseID, MediumID, TightID }

enum	MuonIsoTypes { NoneIso, TrackerIso, PFIso }

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
	ZCounting (const edm::ParameterSet &ps)

	~ZCounting () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &ev, edm::EventSetup const &es) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) override

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

	DQMEDAnalyzer ()

	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) override

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) override

	~DQMEDAnalyzer () override=default

Public Member Functions inherited from edm::one::EDProducer< edm::Accumulator, edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &eSetup) override

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &eSetup) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

void	dqmBeginRun (edm::Run const &, edm::EventSetup const &) override

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &eSetup) override

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)

Private Member Functions
void	analyzeElectrons (edm::Event const &e, edm::EventSetup const &eSetup)

void	analyzeMuons (edm::Event const &e, edm::EventSetup const &eSetup)

bool	ele_probe_selection (double pt, double abseta)

bool	ele_tag_selection (double pt, double abseta)

void	initHLT (const edm::TriggerResults &, const edm::TriggerNames &)

bool	isElectronTrigger (ZCountingTrigger::TTrigger triggerMenu, TriggerBits hltBits)

bool	isElectronTriggerObj (ZCountingTrigger::TTrigger triggerMenu, TriggerObjects hltMatchBits)

bool	isMuonTrigger (const ZCountingTrigger::TTrigger &triggerMenu, const TriggerBits &hltBits)

bool	isMuonTriggerObj (const ZCountingTrigger::TTrigger &triggerMenu, const TriggerObjects &hltMatchBits)

bool	passMuonID (const reco::Muon &muon, const reco::Vertex &vtx, const MuonIDTypes &idType)

bool	passMuonIso (const reco::Muon &muon, const MuonIsoTypes &isoType, const float isoCut)

Private Attributes
const float	ELE_ETA_CRACK_HIGH = 1.56

const float	ELE_ETA_CRACK_LOW = 1.4442

const float	ELE_ETA_CUT_PROBE

const float	ELE_ETA_CUT_TAG

const std::string	ELE_ID_WP

const float	ELE_MASS_CUT_HIGH

const float	ELE_MASS_CUT_LOW

const float	ELE_PT_CUT_PROBE

const float	ELE_PT_CUT_TAG

const float	ELECTRON_MASS = 0.000511

ElectronIdentifier	EleID_

double	EtaCutL1_

double	EtaCutL2_

edm::InputTag	fBeamspotTag

edm::EDGetTokenT< reco::BeamSpot >	fBeamspotToken

edm::InputTag	fConversionTag

edm::EDGetTokenT< reco::ConversionCollection >	fConversionToken

std::string	fElectronName

edm::EDGetTokenT< edm::View< reco::GsfElectron > >	fGsfElectronName_token

edm::InputTag	fHLTObjTag

edm::EDGetTokenT< trigger::TriggerEvent >	fHLTObjTag_token

edm::InputTag	fHLTTag

edm::EDGetTokenT< edm::TriggerResults >	fHLTTag_token

std::string	fMuonName

edm::EDGetTokenT< reco::MuonCollection >	fMuonName_token

std::string	fPVName

edm::EDGetTokenT< reco::VertexCollection >	fPVName_token

edm::InputTag	fRhoTag

edm::EDGetTokenT< double >	fRhoToken

std::string	fSCName

edm::EDGetTokenT< edm::View< reco::SuperCluster > >	fSCName_token

std::string	fTrackName

edm::EDGetTokenT< reco::TrackCollection >	fTrackName_token

std::unique_ptr< ZCountingTrigger::TTrigger >	fTrigger

edm::ParameterSetID	fTriggerNamesID

MonitorElement *	h_ee_mass_HLT_fail_central

MonitorElement *	h_ee_mass_HLT_fail_forward

MonitorElement *	h_ee_mass_HLT_pass_central

MonitorElement *	h_ee_mass_HLT_pass_forward

MonitorElement *	h_ee_mass_id_fail_central

MonitorElement *	h_ee_mass_id_fail_forward

MonitorElement *	h_ee_mass_id_pass_central

MonitorElement *	h_ee_mass_id_pass_forward

MonitorElement *	h_ee_yield_Z_ebeb

MonitorElement *	h_ee_yield_Z_ebee

MonitorElement *	h_ee_yield_Z_eeee

MonitorElement *	h_mass_HLT_fail_central

MonitorElement *	h_mass_HLT_fail_forward

MonitorElement *	h_mass_HLT_pass_central

MonitorElement *	h_mass_HLT_pass_forward

MonitorElement *	h_mass_SIT_fail_central

MonitorElement *	h_mass_SIT_fail_forward

MonitorElement *	h_mass_SIT_pass_central

MonitorElement *	h_mass_SIT_pass_forward

MonitorElement *	h_mass_Sta_fail_central

MonitorElement *	h_mass_Sta_fail_forward

MonitorElement *	h_mass_Sta_pass_central

MonitorElement *	h_mass_Sta_pass_forward

MonitorElement *	h_npv

MonitorElement *	h_yield_Z

MonitorElement *	h_yieldBB_Z

MonitorElement *	h_yieldEE_Z

MuonIDTypes	IDType_ {NoneID}

std::string	IDTypestr_

double	IsoCut_

MuonIsoTypes	IsoType_ {NoneIso}

std::string	IsoTypestr_

int	LumiBin_

double	LumiMax_

double	LumiMin_

int	MassBin_

double	MassMax_

double	MassMin_

const double	MUON_BOUND = 0.9

const double	MUON_MASS = 0.105658369

double	PtCutL1_

double	PtCutL2_

int	PVBin_

double	PVMax_

double	PVMin_

double	VtxAbsZCut_

double	VtxNdofCut_

double	VtxNTracksFitCut_

double	VtxRhoCut_

Additional Inherited Members
Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 42 of file ZCounting.h.

Member Enumeration Documentation

enum ZCounting::MuonIDTypes

Enumerator
NoneID
LooseID
MediumID
TightID

Definition at line 49 of file ZCounting.h.

49 { NoneID, LooseID, MediumID, TightID };

ZCounting::MediumID

Definition: ZCounting.h:49

ZCounting::TightID

Definition: ZCounting.h:49

ZCounting::NoneID

Definition: ZCounting.h:49

ZCounting::LooseID

Definition: ZCounting.h:49

enum ZCounting::MuonIsoTypes

Enumerator
NoneIso
TrackerIso
PFIso

Definition at line 50 of file ZCounting.h.

50 { NoneIso, TrackerIso, PFIso };

ZCounting::TrackerIso

Definition: ZCounting.h:50

ZCounting::PFIso

Definition: ZCounting.h:50

ZCounting::NoneIso

Definition: ZCounting.h:50

Constructor & Destructor Documentation

ZCounting::ZCounting ( const edm::ParameterSet & ps )

Definition at line 25 of file ZCounting.cc.

References ELE_ID_WP, EleID_, EtaCutL1_, EtaCutL2_, fBeamspotTag, fBeamspotToken, fConversionTag, fConversionToken, fElectronName, fGsfElectronName_token, fHLTObjTag, fHLTObjTag_token, fHLTTag, fHLTTag_token, fMuonName, fMuonName_token, fPVName, fPVName_token, fRhoTag, fRhoToken, fSCName, fSCName_token, fTrackName, fTrackName_token, edm::ParameterSet::getUntrackedParameter(), IDType_, IDTypestr_, IsoCut_, IsoType_, IsoTypestr_, LooseID, LumiBin_, LumiMax_, LumiMin_, MassBin_, MassMax_, MassMin_, MediumID, NoneID, NoneIso, PFIso, PtCutL1_, PtCutL2_, PVBin_, PVMax_, PVMin_, ElectronIdentifier::setID(), AlCaHLTBitMon_QueryRunRegistry::string, TightID, TrackerIso, VtxAbsZCut_, VtxNdofCut_, VtxNTracksFitCut_, and VtxRhoCut_.

                                                   :
   fHLTObjTag         (iConfig.getParameter<edm::InputTag>("TriggerEvent")),
   fHLTTag            (iConfig.getParameter<edm::InputTag>("TriggerResults")),
   fPVName            (iConfig.getUntrackedParameter<std::string>("edmPVName","offlinePrimaryVertices")),
   fMuonName          (iConfig.getUntrackedParameter<std::string>("edmName","muons")),
   fTrackName         (iConfig.getUntrackedParameter<std::string>("edmTrackName","generalTracks")),
 
   // Electron-specific Parameters
   fElectronName( iConfig.getUntrackedParameter<std::string>("edmGsfEleName","gedGsfElectrons")),
   fSCName( iConfig.getUntrackedParameter<std::string>("edmSCName","particleFlowEGamma")),
 
   // Electron-specific Tags
   fRhoTag( iConfig.getParameter<edm::InputTag>("rhoname") ),
   fBeamspotTag(iConfig.getParameter<edm::InputTag>("beamspotName") ),
   fConversionTag( iConfig.getParameter<edm::InputTag>("conversionsName")),
 
   // Electron-specific Cuts
   ELE_PT_CUT_TAG(iConfig.getUntrackedParameter<double>("PtCutEleTag")),
   ELE_PT_CUT_PROBE(iConfig.getUntrackedParameter<double>("PtCutEleProbe")),
   ELE_ETA_CUT_TAG(iConfig.getUntrackedParameter<double>("EtaCutEleTag")),
   ELE_ETA_CUT_PROBE(iConfig.getUntrackedParameter<double>("EtaCutEleProbe")),
 
   ELE_MASS_CUT_LOW(iConfig.getUntrackedParameter<double>("MassCutEleLow")),
   ELE_MASS_CUT_HIGH(iConfig.getUntrackedParameter<double>("MassCutEleHigh")),
 
   ELE_ID_WP( iConfig.getUntrackedParameter<std::string>("ElectronIDType","TIGHT")),
   EleID_(ElectronIdentifier(iConfig))
 {
   edm::LogInfo("ZCounting") <<  "Constructor  ZCounting::ZCounting " << std::endl;
   
   //Get parameters from configuration file
   fHLTTag_token    = consumes<edm::TriggerResults>(fHLTTag);
   fHLTObjTag_token = consumes<trigger::TriggerEvent>(fHLTObjTag);
   fPVName_token    = consumes<reco::VertexCollection>(fPVName);
   fMuonName_token  = consumes<reco::MuonCollection>(fMuonName);
   fTrackName_token = consumes<reco::TrackCollection>(fTrackName);
 
   // Electron-specific parameters
   fGsfElectronName_token  = consumes<edm::View<reco::GsfElectron>>(fElectronName);
   fSCName_token           = consumes<edm::View<reco::SuperCluster>>(fSCName);
   fRhoToken               = consumes<double>(fRhoTag);
   fBeamspotToken          = consumes<reco::BeamSpot>(fBeamspotTag);
   fConversionToken        = consumes<reco::ConversionCollection>(fConversionTag);
 
   // Muon-specific Cuts
   IDTypestr_       = iConfig.getUntrackedParameter<std::string>("IDType");
   IsoTypestr_      = iConfig.getUntrackedParameter<std::string>("IsoType");
   IsoCut_          = iConfig.getUntrackedParameter<double>("IsoCut");
 
   if     (IDTypestr_ == "Loose")  IDType_ = LooseID;
   else if(IDTypestr_ == "Medium") IDType_ = MediumID;
   else if(IDTypestr_ == "Tight")  IDType_ = TightID;
   else                            IDType_ = NoneID;
 
   if     (IsoTypestr_ == "Tracker-based") IsoType_ = TrackerIso; 
   else if(IsoTypestr_ == "PF-based")      IsoType_ = PFIso;
   else                                    IsoType_ = NoneIso;
 
   PtCutL1_  = iConfig.getUntrackedParameter<double>("PtCutL1");
   PtCutL2_  = iConfig.getUntrackedParameter<double>("PtCutL2");
   EtaCutL1_ = iConfig.getUntrackedParameter<double>("EtaCutL1");
   EtaCutL2_ = iConfig.getUntrackedParameter<double>("EtaCutL2");
 
   MassBin_  = iConfig.getUntrackedParameter<int>("MassBin");
   MassMin_  = iConfig.getUntrackedParameter<double>("MassMin");
   MassMax_  = iConfig.getUntrackedParameter<double>("MassMax");
 
   LumiBin_  = iConfig.getUntrackedParameter<int>("LumiBin");
   LumiMin_  = iConfig.getUntrackedParameter<double>("LumiMin");
   LumiMax_  = iConfig.getUntrackedParameter<double>("LumiMax");
 
   PVBin_    = iConfig.getUntrackedParameter<int>("PVBin");
   PVMin_    = iConfig.getUntrackedParameter<double>("PVMin");
   PVMax_    = iConfig.getUntrackedParameter<double>("PVMax");
 
   VtxNTracksFitCut_ = iConfig.getUntrackedParameter<double>("VtxNTracksFitMin");
   VtxNdofCut_       = iConfig.getUntrackedParameter<double>("VtxNdofMin");
   VtxAbsZCut_       = iConfig.getUntrackedParameter<double>("VtxAbsZMax");
   VtxRhoCut_        = iConfig.getUntrackedParameter<double>("VtxRhoMax");
 
   EleID_.setID(ELE_ID_WP);
 }

ZCounting::~ZCounting ( )

override

Definition at line 111 of file ZCounting.cc.

 {
   edm::LogInfo("ZCounting") <<  "Destructor ZCounting::~ZCounting " << std::endl;
 }

Member Function Documentation

void ZCounting::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 188 of file ZCounting.cc.

References analyzeElectrons(), and analyzeMuons().

 {// Fill event tree on the fly 
   edm::LogInfo("ZCounting") <<  "ZCounting::analyze" << std::endl;
   analyzeMuons(iEvent, iSetup);
   analyzeElectrons(iEvent, iSetup);
 }

void ZCounting::analyzeElectrons	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

private

Fill for ID efficiency

Fill for HLT efficiency

Definition at line 444 of file ZCounting.cc.

References edm::HLTGlobalStatus::accept(), reco::LeafCandidate::charge(), ELE_ETA_CRACK_LOW, ELE_MASS_CUT_HIGH, ELE_MASS_CUT_LOW, ele_probe_selection(), ele_tag_selection(), ELECTRON_MASS, electrons_cff::electrons, EleID_, SimCluster::energy(), reco::LeafCandidate::eta(), SimCluster::eta(), fBeamspotToken, fConversionToken, fGsfElectronName_token, fHLTObjTag_token, fHLTTag_token, MonitorElement::Fill(), HcalObjRepresent::Fill(), fPVName_token, fRhoToken, fSCName_token, fTrigger, fTriggerNamesID, edm::Event::getByToken(), h_ee_mass_HLT_fail_central, h_ee_mass_HLT_fail_forward, h_ee_mass_HLT_pass_central, h_ee_mass_HLT_pass_forward, h_ee_mass_id_fail_central, h_ee_mass_id_fail_forward, h_ee_mass_id_pass_central, h_ee_mass_id_pass_forward, h_ee_yield_Z_ebeb, h_ee_yield_Z_ebee, h_ee_yield_Z_eeee, initHLT(), isElectronTrigger(), isElectronTriggerObj(), edm::Ptr< T >::isNonnull(), edm::HandleBase::isValid(), eostools::ls(), edm::EventBase::luminosityBlock(), or, edm::TriggerNames::parameterSetID(), ElectronIdentifier::passID(), reco::LeafCandidate::phi(), SimCluster::phi(), funct::pow(), edm::Handle< T >::product(), EnergyCorrector::pt, reco::LeafCandidate::pt(), hiDetachedQuadStep_cff::pt1, SimDataFormats::CaloAnalysis::sc, ElectronIdentifier::setRho(), mathSSE::sqrt(), edm::Event::triggerNames(), badGlobalMuonTaggersAOD_cff::vtx, VtxAbsZCut_, VtxNdofCut_, VtxNTracksFitCut_, and VtxRhoCut_.

Referenced by analyze().

                                                                                     {
   edm::LogInfo("ZCounting") <<  "ZCounting::analyzeElectrons" << std::endl;
 
   //-------------------------------
   //--- Vertex
   //-------------------------------
   edm::Handle<reco::VertexCollection> hVertexProduct;
   iEvent.getByToken(fPVName_token,hVertexProduct);
   if(!hVertexProduct.isValid()) return;
 
   const reco::VertexCollection *pvCol = hVertexProduct.product();
   int nvtx = 0;
 
   for(auto const & vtx : *pvCol) {
     if(vtx.isFake())                             continue;
     if(vtx.tracksSize()     < VtxNTracksFitCut_) continue;
     if(vtx.ndof()           < VtxNdofCut_)       continue;
     if(fabs(vtx.z())        > VtxAbsZCut_)       continue;
     if(vtx.position().Rho() > VtxRhoCut_)        continue;
 
     nvtx++;
   }
 
   // Good vertex requirement
   if(nvtx==0) return;
 
   //-------------------------------
   //--- Trigger
   //-------------------------------
   edm::Handle<edm::TriggerResults> hTrgRes;
   iEvent.getByToken(fHLTTag_token,hTrgRes);
   if(!hTrgRes.isValid()) return;
 
   edm::Handle<trigger::TriggerEvent> hTrgEvt;
   iEvent.getByToken(fHLTObjTag_token,hTrgEvt);
 
 
   const edm::TriggerNames &triggerNames = iEvent.triggerNames(*hTrgRes);
   Bool_t config_changed = false;
   if(fTriggerNamesID != triggerNames.parameterSetID()) {
     fTriggerNamesID = triggerNames.parameterSetID();
     config_changed  = true;
   }
   if(config_changed) {
     initHLT(*hTrgRes, triggerNames);
   }
 
   TriggerBits triggerBits;
   for(unsigned int irec=0; irec<fTrigger->fRecords.size(); irec++) {
     if(fTrigger->fRecords[irec].hltPathIndex == (unsigned int)-1) continue;
     if(hTrgRes->accept(fTrigger->fRecords[irec].hltPathIndex)) {
       triggerBits [fTrigger->fRecords[irec].baconTrigBit] = true;
     }
   }
 
   // Trigger requirement
   if(!isElectronTrigger(*fTrigger, triggerBits)) return;
 
   // Get Electrons
   edm::Handle<edm::View<reco::GsfElectron> > electrons;
   iEvent.getByToken(fGsfElectronName_token, electrons);
 
   // Get SuperClusters
   edm::Handle<edm::View<reco::SuperCluster> > superclusters;
   iEvent.getByToken(fSCName_token, superclusters);
 
   // Get Rho
   edm::Handle<double> rhoHandle;
   iEvent.getByToken(fRhoToken, rhoHandle);
   EleID_.setRho(*rhoHandle);
 
   // Get beamspot
   edm::Handle<reco::BeamSpot> beamspotHandle;
   iEvent.getByToken(fBeamspotToken, beamspotHandle);
 
   // Conversions
   edm::Handle<reco::ConversionCollection> conversionsHandle;
   iEvent.getByToken(fConversionToken, conversionsHandle);
 
 
   edm::Ptr<reco::GsfElectron> eleProbe;
   enum { eEleEle2HLT=1, eEleEle1HLT1L1, eEleEle1HLT, eEleEleNoSel, eEleSC };  // event category enum
 
   // Loop over Tags
   for (size_t itag = 0; itag < electrons->size(); ++itag){
     const auto el1 = electrons->ptrAt(itag);
     if( not EleID_.passID(el1,beamspotHandle,conversionsHandle) ) continue;
 
     float pt1  = el1->pt();
     float eta1 = el1->eta();
     float phi1 = el1->phi();
 
     if(!isElectronTriggerObj(*fTrigger, TriggerTools::matchHLT(eta1, phi1, fTrigger->fRecords, *hTrgEvt))) continue;
     TLorentzVector vTag(0.,0.,0.,0.);
     vTag.SetPtEtaPhiM(pt1, eta1, phi1, ELECTRON_MASS);
 
 
     // Tag selection: kinematic cuts, lepton selection and trigger matching
     double tag_pt = vTag.Pt();
     double tag_abseta = fabs(vTag.Eta());
 
     bool tag_is_valid_tag = ele_tag_selection(tag_pt,tag_abseta);
     bool tag_is_valid_probe = ele_probe_selection(tag_pt,tag_abseta);
 
     if( not (tag_is_valid_tag or tag_is_valid_probe) ) continue;
 
     // Loop over probes
     for (size_t iprobe = 0; iprobe < superclusters->size(); ++iprobe){
       // Initialize probe
       const auto sc = superclusters->ptrAt(iprobe);
       if(*sc == *(el1->superCluster())) {
         continue;
       }
 
       // Find matching electron
       for (size_t iele = 0; iele < electrons->size(); ++iele){
         if(iele == itag) continue;
         const auto ele = electrons->ptrAt(iele);
         if(*sc == *(ele->superCluster())) {
           eleProbe = ele;
           break;
         }
       }
 
       // Assign final probe 4-vector
       TLorentzVector vProbe(0.,0.,0.,0.);
       if(eleProbe.isNonnull()){
         vProbe.SetPtEtaPhiM( eleProbe->pt(), eleProbe->eta(), eleProbe->phi(), ELECTRON_MASS);
       } else {
         double pt = sc->energy() * sqrt( 1 - pow(tanh(sc->eta()),2) );
         vProbe.SetPtEtaPhiM( pt, sc->eta(), sc->phi(), ELECTRON_MASS);
       }
 
       // Probe Selection
       double probe_pt = vProbe.Pt();
       double probe_abseta = fabs(sc->eta());
       bool probe_is_valid_probe = ele_probe_selection(probe_pt, probe_abseta);
       if( !probe_is_valid_probe ) continue;
 
       // Good Probe found!
 
       // Require good Z
       TLorentzVector vDilep = vTag + vProbe;
 
       if((vDilep.M()<ELE_MASS_CUT_LOW) || (vDilep.M()>ELE_MASS_CUT_HIGH)) continue;
       if(eleProbe.isNonnull() and (eleProbe->charge() != - el1->charge())) continue;
 
       // Good Z found!
 
       long ls = iEvent.luminosityBlock();
       bool probe_pass_trigger = isElectronTriggerObj(*fTrigger, TriggerTools::matchHLT(vProbe.Eta(), vProbe.Phi(), fTrigger->fRecords, *hTrgEvt));
       bool probe_pass_id = eleProbe.isNonnull() and EleID_.passID(eleProbe,beamspotHandle,conversionsHandle);
 
       bool probe_is_forward = probe_abseta > ELE_ETA_CRACK_LOW;
       bool tag_is_forward = tag_abseta > ELE_ETA_CRACK_LOW;
 
       if(probe_pass_id) {
         if(probe_is_forward and tag_is_forward) {
           h_ee_yield_Z_eeee -> Fill(ls);
         } else if(!probe_is_forward and !tag_is_forward) {
           h_ee_yield_Z_ebeb -> Fill(ls);
         } else {
           h_ee_yield_Z_ebee -> Fill(ls);
         }
       }
 
       if(!tag_is_valid_tag) continue;
 
       if(probe_pass_id) {
         if(probe_is_forward) {
           h_ee_mass_id_pass_forward->Fill(ls, vDilep.M());
         } else {
           h_ee_mass_id_pass_central->Fill(ls, vDilep.M());
         }
       } else {
           if(probe_is_forward) {
             h_ee_mass_id_fail_forward->Fill(ls, vDilep.M());
           } else {
             h_ee_mass_id_fail_central->Fill(ls, vDilep.M());
           }
       }
 
       if(probe_pass_id and probe_pass_trigger) {
         if(probe_is_forward) {
           h_ee_mass_HLT_pass_forward->Fill(ls, vDilep.M());
         } else {
           h_ee_mass_HLT_pass_central->Fill(ls, vDilep.M());
         }
       } else if (probe_pass_id) {
         if(probe_is_forward) {
           h_ee_mass_HLT_fail_forward->Fill(ls, vDilep.M());
         } else {
           h_ee_mass_HLT_fail_central->Fill(ls, vDilep.M());
         }
       }
     } // End of probe loop
   }//End of tag loop
 
 }

void ZCounting::analyzeMuons	(	edm::Event const &	e,
		edm::EventSetup const &	eSetup
	)

private

Definition at line 195 of file ZCounting.cc.

References edm::HLTGlobalStatus::accept(), EtaCutL1_, EtaCutL2_, fHLTObjTag_token, fHLTTag_token, MonitorElement::Fill(), fMuonName_token, fPVName_token, fTrackName_token, fTrigger, fTriggerNamesID, edm::Event::getByToken(), h_mass_HLT_fail_central, h_mass_HLT_fail_forward, h_mass_HLT_pass_central, h_mass_HLT_pass_forward, h_mass_SIT_fail_central, h_mass_SIT_fail_forward, h_mass_SIT_pass_central, h_mass_SIT_pass_forward, h_mass_Sta_fail_central, h_mass_Sta_fail_forward, h_mass_Sta_pass_central, h_mass_Sta_pass_forward, h_npv, h_yield_Z, h_yieldBB_Z, h_yieldEE_Z, IDType_, initHLT(), reco::isMuon(), isMuonTrigger(), isMuonTriggerObj(), IsoCut_, IsoType_, edm::HandleBase::isValid(), edm::EventBase::luminosityBlock(), MassMax_, MassMin_, MUON_BOUND, MUON_MASS, edm::TriggerNames::parameterSetID(), passMuonID(), passMuonIso(), edm::Handle< T >::product(), hiDetachedQuadStep_cff::pt1, hiDetachedQuadStep_cff::pt2, PtCutL1_, PtCutL2_, MetAnalyzer::pv(), q1, q2, edm::Event::triggerNames(), VtxAbsZCut_, VtxNdofCut_, VtxNTracksFitCut_, and VtxRhoCut_.

Referenced by analyze().

                                                                                 {
   edm::LogInfo("ZCounting") <<  "ZCounting::analyzeMuons" << std::endl;
   //-------------------------------
   //--- Vertex 
   //-------------------------------
   edm::Handle<reco::VertexCollection> hVertexProduct;
   iEvent.getByToken(fPVName_token,hVertexProduct);
   if(!hVertexProduct.isValid()) return;
 
   const reco::VertexCollection *pvCol = hVertexProduct.product();
   const reco::Vertex* pv = &(*pvCol->begin());
   int nvtx = 0;
  
   for(auto const & itVtx : *hVertexProduct) {
     if(itVtx.isFake())                             continue;
     if(itVtx.tracksSize()     < VtxNTracksFitCut_) continue;
     if(itVtx.ndof()           < VtxNdofCut_)       continue;
     if(fabs(itVtx.z())        > VtxAbsZCut_)       continue;
     if(itVtx.position().Rho() > VtxRhoCut_)        continue;
 
     if(nvtx==0) {
       pv = &itVtx;
     }
     nvtx++;
   }
 
   h_npv->Fill(iEvent.luminosityBlock(), nvtx);
 
   // Good vertex requirement
   if(nvtx==0) return;
 
   //-------------------------------
   //--- Trigger 
   //-------------------------------
   edm::Handle<edm::TriggerResults> hTrgRes;
   iEvent.getByToken(fHLTTag_token,hTrgRes);
   if(!hTrgRes.isValid()) return;
 
   edm::Handle<trigger::TriggerEvent> hTrgEvt;
   iEvent.getByToken(fHLTObjTag_token,hTrgEvt);
 
   const edm::TriggerNames &triggerNames = iEvent.triggerNames(*hTrgRes);
   bool config_changed = false;
   if(fTriggerNamesID != triggerNames.parameterSetID()) {
     fTriggerNamesID = triggerNames.parameterSetID();
     config_changed  = true;
   }
   if(config_changed) {
     initHLT(*hTrgRes, triggerNames);
   }
 
   TriggerBits triggerBits;
   for(unsigned int irec=0; irec<fTrigger->fRecords.size(); irec++) {
     if(fTrigger->fRecords[irec].hltPathIndex == (unsigned int)-1) continue;
     if(hTrgRes->accept(fTrigger->fRecords[irec].hltPathIndex)) {
       triggerBits [fTrigger->fRecords[irec].baconTrigBit] = true;
     }
   }
   //if(fSkipOnHLTFail && triggerBits == 0) return;
 
   // Trigger requirement
   if(!isMuonTrigger(*fTrigger, triggerBits)) return;
 
   //-------------------------------
   //--- Muons and Tracks 
   //-------------------------------
   edm::Handle<reco::MuonCollection> hMuonProduct;
   iEvent.getByToken(fMuonName_token,hMuonProduct);
   if(!hMuonProduct.isValid()) return;
 
   edm::Handle<reco::TrackCollection> hTrackProduct;
   iEvent.getByToken(fTrackName_token,hTrackProduct);
   if(!hTrackProduct.isValid()) return;
 
   TLorentzVector vTag(0.,0.,0.,0.);
   TLorentzVector vProbe(0.,0.,0.,0.);
   TLorentzVector vTrack(0.,0.,0.,0.);
 
   // Tag loop
   for(auto const & itMu1 : *hMuonProduct) {
 
     float pt1  = itMu1.muonBestTrack()->pt();
     float eta1 = itMu1.muonBestTrack()->eta();
     float phi1 = itMu1.muonBestTrack()->phi();
     float q1   = itMu1.muonBestTrack()->charge();
 
     // Tag selection: kinematic cuts, lepton selection and trigger matching
     if(pt1        < PtCutL1_)  continue;
     if(fabs(eta1) > EtaCutL1_) continue;
     if(!(passMuonID(itMu1, *pv, IDType_) && passMuonIso(itMu1, IsoType_, IsoCut_))) continue;
     if(!isMuonTriggerObj(*fTrigger, TriggerTools::matchHLT(eta1, phi1, fTrigger->fRecords, *hTrgEvt))) continue;
 
     vTag.SetPtEtaPhiM(pt1, eta1, phi1, MUON_MASS);
 
     // Probe loop over muons
     for(auto const & itMu2 : *hMuonProduct) {
       if(&itMu2 == &itMu1) continue;
 
       float pt2  = itMu2.muonBestTrack()->pt();
       float eta2 = itMu2.muonBestTrack()->eta();
       float phi2 = itMu2.muonBestTrack()->phi();
       float q2   = itMu2.muonBestTrack()->charge();
 
       // Probe selection: kinematic cuts and opposite charge requirement
       if(pt2        < PtCutL2_)  continue;
       if(fabs(eta2) > EtaCutL2_) continue;
       if(q1 == q2)               continue;
 
       vProbe.SetPtEtaPhiM(pt2, eta2, phi2, MUON_MASS);
 
       // Mass window
       TLorentzVector vDilep = vTag + vProbe;
       float dilepMass = vDilep.M();
       if((dilepMass < MassMin_) || (dilepMass > MassMax_)) continue;
 
       bool isTagCentral   = false;
       bool isProbeCentral = false;
       if(fabs(eta1) < MUON_BOUND) isTagCentral   = true;
       if(fabs(eta2) < MUON_BOUND) isProbeCentral = true;
 
       // Determine event category for efficiency calculation
       if(passMuonID(itMu2, *pv, IDType_) && passMuonIso(itMu2, IsoType_, IsoCut_)){
         if(isMuonTriggerObj(*fTrigger, TriggerTools::matchHLT(eta2, phi2, fTrigger->fRecords, *hTrgEvt))){
           // category 2HLT: both muons passing trigger requirements
           if(&itMu1>&itMu2) continue;  // make sure we don't double count MuMu2HLT category
 
           // Fill twice for each event, since both muons pass trigger 
           if(isTagCentral){
             h_mass_HLT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_Sta_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
           }
           else
           {
             h_mass_HLT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_Sta_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
           }
 
           if(isProbeCentral){
             h_mass_HLT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_Sta_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
           }
           else
           {
             h_mass_HLT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_Sta_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
           }
 
         }
         else{
           // category 1HLT: probe passing selection but not trigger
           if(isProbeCentral){
             h_mass_HLT_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_SIT_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_Sta_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
           }
           else
           {
             h_mass_HLT_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_SIT_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
             h_mass_Sta_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
           }
 
         }
         // category 2HLT + 1HLT: Fill once for Z yield 
         h_yield_Z->Fill(iEvent.luminosityBlock());
         if(isTagCentral && isProbeCentral) h_yieldBB_Z->Fill(iEvent.luminosityBlock());
     else if(!isTagCentral && !isProbeCentral) h_yieldEE_Z->Fill(iEvent.luminosityBlock());
       }
       else if(itMu2.isGlobalMuon()){
         // category NoSel: probe is a GLB muon but failing selection 
         if(isProbeCentral){
           h_mass_SIT_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
           h_mass_Sta_pass_central->Fill(iEvent.luminosityBlock(), dilepMass);
         }
         else
         {
           h_mass_SIT_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
           h_mass_Sta_pass_forward->Fill(iEvent.luminosityBlock(), dilepMass);
         }
       }
       else if(itMu2.isStandAloneMuon()){
         // category STA: probe is a STA muon
         if(isProbeCentral){
           h_mass_Sta_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
         }
         else
         {
           h_mass_Sta_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
         }
       }
       else if(itMu2.innerTrack()->hitPattern().trackerLayersWithMeasurement() >= 6 && itMu2.innerTrack()->hitPattern().numberOfValidPixelHits() >= 1){
         // cateogry Trk: probe is a tracker track
         if(isProbeCentral){
           h_mass_Sta_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
         }
         else
         {
           h_mass_Sta_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
         }
       }
 
     }// End of probe loop over muons
 
     // Probe loop over tracks, only for standalone efficiency calculation
     for(auto const & itTrk : *hTrackProduct) {
 
       // Check track is not a muon
       bool isMuon = false;
       for(auto const & itMu : *hMuonProduct) {
         if(itMu.innerTrack().isNonnull() && itMu.innerTrack().get() == &itTrk) {
           isMuon = true;
           break;
         }
       }
       if(isMuon) continue;
 
       float pt2  = itTrk.pt();
       float eta2 = itTrk.eta();
       float phi2 = itTrk.phi();
       float q2   = itTrk.charge();
 
       // Probe selection:  kinematic cuts and opposite charge requirement
       if(pt2        < PtCutL2_)  continue;
       if(fabs(eta2) > EtaCutL2_) continue;
       if(q1 == q2)               continue;
 
       vTrack.SetPtEtaPhiM(pt2, eta2, phi2, MUON_MASS);
 
       TLorentzVector vDilep = vTag + vTrack;
       float dilepMass = vDilep.M();
       if((dilepMass < MassMin_) || (dilepMass > MassMax_)) continue;
 
       bool isTrackCentral = false;
       if(fabs(eta2) > MUON_BOUND) isTrackCentral = true;
 
       if(itTrk.hitPattern().trackerLayersWithMeasurement() >= 6 && itTrk.hitPattern().numberOfValidPixelHits() >= 1){
         if(isTrackCentral) h_mass_Sta_fail_central->Fill(iEvent.luminosityBlock(), dilepMass);
         else               h_mass_Sta_fail_forward->Fill(iEvent.luminosityBlock(), dilepMass);
       }
 
     }//End of probe loop over tracks
 
   }//End of tag loop
 
 }

void ZCounting::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	eSetup
	)

overrideprotected

Definition at line 178 of file ZCounting.cc.

 {
   edm::LogInfo("ZCounting") <<  "ZCounting::beginLuminosityBlock" << std::endl;
 }

void ZCounting::bookHistograms	(	DQMStore::IBooker &	ibooker_,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 130 of file ZCounting.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::cd(), h_ee_mass_HLT_fail_central, h_ee_mass_HLT_fail_forward, h_ee_mass_HLT_pass_central, h_ee_mass_HLT_pass_forward, h_ee_mass_id_fail_central, h_ee_mass_id_fail_forward, h_ee_mass_id_pass_central, h_ee_mass_id_pass_forward, h_ee_yield_Z_ebeb, h_ee_yield_Z_ebee, h_ee_yield_Z_eeee, h_mass_HLT_fail_central, h_mass_HLT_fail_forward, h_mass_HLT_pass_central, h_mass_HLT_pass_forward, h_mass_SIT_fail_central, h_mass_SIT_fail_forward, h_mass_SIT_pass_central, h_mass_SIT_pass_forward, h_mass_Sta_fail_central, h_mass_Sta_fail_forward, h_mass_Sta_pass_central, h_mass_Sta_pass_forward, h_npv, h_yield_Z, h_yieldBB_Z, h_yieldEE_Z, LumiBin_, LumiMax_, LumiMin_, MassBin_, MassMax_, MassMin_, PVBin_, PVMax_, PVMin_, and DQMStore::IBooker::setCurrentFolder().

 {
   edm::LogInfo("ZCounting") <<  "ZCounting::bookHistograms" << std::endl;
 
   ibooker_.cd();
   ibooker_.setCurrentFolder("ZCounting/Histograms");
 
 
   // Muon histograms
   h_mass_HLT_pass_central = ibooker_.book2D("h_mass_HLT_pass_central", "h_mass_HLT_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_HLT_pass_forward = ibooker_.book2D("h_mass_HLT_pass_forward", "h_mass_HLT_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_HLT_fail_central = ibooker_.book2D("h_mass_HLT_fail_central", "h_mass_HLT_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_HLT_fail_forward = ibooker_.book2D("h_mass_HLT_fail_forward", "h_mass_HLT_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
 
   h_mass_SIT_pass_central = ibooker_.book2D("h_mass_SIT_pass_central", "h_mass_SIT_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_SIT_pass_forward = ibooker_.book2D("h_mass_SIT_pass_forward", "h_mass_SIT_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_SIT_fail_central = ibooker_.book2D("h_mass_SIT_fail_central", "h_mass_SIT_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_SIT_fail_forward = ibooker_.book2D("h_mass_SIT_fail_forward", "h_mass_SIT_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
 
   h_mass_Sta_pass_central = ibooker_.book2D("h_mass_Sta_pass_central", "h_mass_Sta_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_Sta_pass_forward = ibooker_.book2D("h_mass_Sta_pass_forward", "h_mass_Sta_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_Sta_fail_central = ibooker_.book2D("h_mass_Sta_fail_central", "h_mass_Sta_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_mass_Sta_fail_forward = ibooker_.book2D("h_mass_Sta_fail_forward", "h_mass_Sta_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
 
   h_npv                   = ibooker_.book2D("h_npv",     "h_npv",     LumiBin_, LumiMin_, LumiMax_, PVBin_, PVMin_, PVMax_);
   h_yield_Z               = ibooker_.book1D("h_yield_Z", "h_yield_Z", LumiBin_, LumiMin_, LumiMax_);
   h_yieldBB_Z             = ibooker_.book1D("h_yieldBB_Z", "h_yieldBB_Z", LumiBin_, LumiMin_, LumiMax_);
   h_yieldEE_Z             = ibooker_.book1D("h_yieldEE_Z", "h_yieldEE_Z", LumiBin_, LumiMin_, LumiMax_);
 
 
   // Electron histograms
   h_ee_mass_id_pass_central  = ibooker_.book2D("h_ee_mass_id_pass_central", "h_ee_mass_id_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_ee_mass_id_fail_central  = ibooker_.book2D("h_ee_mass_id_fail_central", "h_ee_mass_id_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_ee_mass_id_pass_forward  = ibooker_.book2D("h_ee_mass_id_pass_forward", "h_ee_mass_id_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_ee_mass_id_fail_forward  = ibooker_.book2D("h_ee_mass_id_fail_forward", "h_ee_mass_id_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
 
   h_ee_mass_HLT_pass_central = ibooker_.book2D("h_ee_mass_HLT_pass_central", "h_ee_mass_HLT_pass_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_ee_mass_HLT_fail_central = ibooker_.book2D("h_ee_mass_HLT_fail_central", "h_ee_mass_HLT_fail_central", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_ee_mass_HLT_pass_forward = ibooker_.book2D("h_ee_mass_HLT_pass_forward", "h_ee_mass_HLT_pass_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
   h_ee_mass_HLT_fail_forward = ibooker_.book2D("h_ee_mass_HLT_fail_forward", "h_ee_mass_HLT_fail_forward", LumiBin_, LumiMin_, LumiMax_, MassBin_, MassMin_, MassMax_);
 
   h_ee_yield_Z_ebeb       = ibooker_.book1D("h_ee_yield_Z_ebeb", "h_ee_yield_Z_ebeb", LumiBin_, LumiMin_, LumiMax_);
   h_ee_yield_Z_ebee       = ibooker_.book1D("h_ee_yield_Z_ebee", "h_ee_yield_Z_ebee", LumiBin_, LumiMin_, LumiMax_);
   h_ee_yield_Z_eeee       = ibooker_.book1D("h_ee_yield_Z_eeee", "h_ee_yield_Z_eeee", LumiBin_, LumiMin_, LumiMax_);
 }

void ZCounting::dqmBeginRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 119 of file ZCounting.cc.

References fTrigger.

 {
   edm::LogInfo("ZCounting") <<  "ZCounting::beginRun" << std::endl;
 
   // Triggers
   fTrigger.reset(new ZCountingTrigger::TTrigger());
   
 }

bool ZCounting::ele_probe_selection	(	double	pt,
		double	abseta
	)

private

Definition at line 647 of file ZCounting.cc.

References ELE_ETA_CRACK_HIGH, ELE_ETA_CRACK_LOW, ELE_ETA_CUT_PROBE, and ELE_PT_CUT_PROBE.

Referenced by analyzeElectrons().

                                                            {
   if(pt < ELE_PT_CUT_PROBE) return false;
   if(abseta > ELE_ETA_CUT_PROBE) return false;
   if( (abseta > ELE_ETA_CRACK_LOW) and (abseta < ELE_ETA_CRACK_HIGH) ) return false;
   return true;
 }

bool ZCounting::ele_tag_selection	(	double	pt,
		double	abseta
	)

private

Definition at line 653 of file ZCounting.cc.

References ELE_ETA_CRACK_HIGH, ELE_ETA_CRACK_LOW, ELE_ETA_CUT_TAG, and ELE_PT_CUT_TAG.

Referenced by analyzeElectrons().

                                                          {
   if(pt < ELE_PT_CUT_TAG) return false;
   if(abseta > ELE_ETA_CUT_TAG) return false;
   if( (abseta > ELE_ETA_CRACK_LOW) and (abseta < ELE_ETA_CRACK_HIGH) ) return false;
   return true;
 }

void ZCounting::endLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	eSetup
	)

overrideprotected

Definition at line 662 of file ZCounting.cc.

 {
   edm::LogInfo("ZCounting") <<  "ZCounting::endLuminosityBlock" << std::endl;
 }

void ZCounting::initHLT	(	const edm::TriggerResults &	result,
		const edm::TriggerNames &	triggerNames
	)

private

Definition at line 671 of file ZCounting.cc.

References fTrigger, createfilelist::int, edm::is_glob(), match(), patRefSel_triggerMatching_cfi::matches, listBenchmarks::pattern, edm::regexMatch(), edm::HLTGlobalStatus::size(), AlCaHLTBitMon_QueryRunRegistry::string, edm::TriggerNames::triggerIndex(), and edm::TriggerNames::triggerNames().

Referenced by analyzeElectrons(), and analyzeMuons().

 {
   for(unsigned int irec=0; irec<fTrigger->fRecords.size(); irec++) {
     fTrigger->fRecords[irec].hltPathName  = "";
     fTrigger->fRecords[irec].hltPathIndex = (unsigned int)-1;
     const std::string pattern = fTrigger->fRecords[irec].hltPattern;
     if(edm::is_glob(pattern)) {  // handle pattern with wildcards (*,?)
       std::vector<std::vector<std::string>::const_iterator> matches = edm::regexMatch(triggerNames.triggerNames(), pattern);
       if(matches.empty()) {
         edm::LogWarning("ZCounting") << "requested pattern [" << pattern << "] does not match any HLT paths" << std::endl;
       } else {
         BOOST_FOREACH(std::vector<std::string>::const_iterator match, matches) {
           fTrigger->fRecords[irec].hltPathName = *match;
         }
       }
     } else {  // take full HLT path name given
       fTrigger->fRecords[irec].hltPathName = pattern;
     }
     // Retrieve index in trigger menu corresponding to HLT path
     unsigned int index = triggerNames.triggerIndex(fTrigger->fRecords[irec].hltPathName);
     if(index < result.size()) {  // check for valid index
       fTrigger->fRecords[irec].hltPathIndex = index;
     }
   }
 }

bool ZCounting::isElectronTrigger	(	ZCountingTrigger::TTrigger	triggerMenu,
		TriggerBits	hltBits
	)

private

Definition at line 730 of file ZCounting.cc.

References ZCountingTrigger::TTrigger::pass().

Referenced by analyzeElectrons().

 {
   return triggerMenu.pass("HLT_Ele35_WPTight_Gsf_v*",hltBits);
 }

bool ZCounting::isElectronTriggerObj	(	ZCountingTrigger::TTrigger	triggerMenu,
		TriggerObjects	hltMatchBits
	)

private

Definition at line 735 of file ZCounting.cc.

References DEFINE_FWK_MODULE, and ZCountingTrigger::TTrigger::passObj().

Referenced by analyzeElectrons().

 {
   return triggerMenu.passObj("HLT_Ele35_WPTight_Gsf_v*","hltEle35noerWPTightGsfTrackIsoFilter",hltMatchBits);
 }

bool ZCounting::isMuonTrigger	(	const ZCountingTrigger::TTrigger &	triggerMenu,
		const TriggerBits &	hltBits
	)

private

Definition at line 698 of file ZCounting.cc.

References ZCountingTrigger::TTrigger::pass().

Referenced by analyzeMuons().

 {
   return triggerMenu.pass("HLT_IsoMu27_v*",hltBits);
 }

bool ZCounting::isMuonTriggerObj	(	const ZCountingTrigger::TTrigger &	triggerMenu,
		const TriggerObjects &	hltMatchBits
	)

private

Definition at line 704 of file ZCounting.cc.

References ZCountingTrigger::TTrigger::passObj().

Referenced by analyzeMuons().

 {
   return triggerMenu.passObj("HLT_IsoMu27_v*","hltL3crIsoL1sMu22Or25L1f0L2f10QL3f27QL3trkIsoFiltered0p07",hltMatchBits);
 }

bool ZCounting::passMuonID	(	const reco::Muon &	muon,
		const reco::Vertex &	vtx,
		const MuonIDTypes &	idType
	)

private

Definition at line 710 of file ZCounting.cc.

References muon::isLooseMuon(), muon::isMediumMuon(), muon::isTightMuon(), LooseID, MediumID, NoneID, and TightID.

Referenced by analyzeMuons().

 {//Muon ID selection, using internal function "DataFormats/MuonReco/src/MuonSelectors.cc
 
   if     (idType == LooseID  && muon::isLooseMuon(muon))      return true;
   else if(idType == MediumID && muon::isMediumMuon(muon))     return true;
   else if(idType == TightID  && muon::isTightMuon(muon, vtx)) return true;
   else if(idType == NoneID)                                   return true;
   else                                                        return false;
 }

bool ZCounting::passMuonIso	(	const reco::Muon &	muon,
		const MuonIsoTypes &	isoType,
		const float	isoCut
	)

private

Definition at line 720 of file ZCounting.cc.

References reco::Muon::isolationR03(), SiStripPI::max, NoneIso, PFIso, reco::Muon::pfIsolationR04(), reco::MuonPFIsolation::sumChargedHadronPt, reco::MuonPFIsolation::sumNeutralHadronEt, reco::MuonPFIsolation::sumPhotonEt, reco::MuonIsolation::sumPt, reco::MuonPFIsolation::sumPUPt, and TrackerIso.

Referenced by analyzeMuons().

 {//Muon isolation selection, up-to-date with MUO POG recommendation
 
     if(isoType == TrackerIso && muon.isolationR03().sumPt < isoCut) return true;
     else if(isoType == PFIso && muon.pfIsolationR04().sumChargedHadronPt + std::max(0.,muon.pfIsolationR04().sumNeutralHadronEt + muon.pfIsolationR04().sumPhotonEt - 0.5*muon.pfIsolationR04().sumPUPt) < isoCut) return true;
     else if(isoType == NoneIso) return true;
     else                        return false;
 }