Inheritance diagram for AlCaHBHEMuonProducer:

Public Member Functions
	AlCaHBHEMuonProducer (edm::ParameterSet const &, const alCaHBHEMuonProducer::Counters *count)

void	endStream () override

void	produce (edm::Event &, const edm::EventSetup &) override

	~AlCaHBHEMuonProducer () override

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< alCaHBHEMuonProducer::Counters > >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

static void	globalEndJob (const alCaHBHEMuonProducer::Counters *counters)

static std::unique_ptr< alCaHBHEMuonProducer::Counters >	initializeGlobalCache (edm::ParameterSet const &)

Private Member Functions
bool	select (const reco::MuonCollection &)

Private Attributes
const edm::InputTag	labelBS_

const edm::InputTag	labelEB_

const edm::InputTag	labelEE_

const edm::InputTag	labelHBHE_

const edm::InputTag	labelMuon_

const edm::InputTag	labelVtx_

unsigned int	nAll_

unsigned int	nGood_

const double	pMuonMin_

edm::EDGetTokenT< reco::BeamSpot >	tok_BS_

edm::EDGetTokenT< EcalRecHitCollection >	tok_EB_

edm::EDGetTokenT< EcalRecHitCollection >	tok_EE_

edm::EDGetTokenT< HBHERecHitCollection >	tok_HBHE_

edm::EDGetTokenT< reco::MuonCollection >	tok_Muon_

edm::EDGetTokenT< reco::VertexCollection >	tok_Vtx_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< alCaHBHEMuonProducer::Counters > >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 48 of file AlCaHBHEMuonProducer.cc.

Constructor & Destructor Documentation

◆ AlCaHBHEMuonProducer()

AlCaHBHEMuonProducer::AlCaHBHEMuonProducer	(	edm::ParameterSet const &	iConfig,
		const alCaHBHEMuonProducer::Counters *	count
	)

explicit

Definition at line 79 of file AlCaHBHEMuonProducer.cc.

References edm::InputTag::instance(), edm::InputTag::label(), labelBS_, labelEB_, labelEE_, labelHBHE_, labelMuon_, labelVtx_, pMuonMin_, tok_BS_, tok_EB_, tok_EE_, tok_HBHE_, tok_Muon_, and tok_Vtx_.

     : nAll_(0),
       nGood_(0),
       labelBS_(iConfig.getParameter<edm::InputTag>("BeamSpotLabel")),
       labelVtx_(iConfig.getParameter<edm::InputTag>("VertexLabel")),
       labelEB_(iConfig.getParameter<edm::InputTag>("EBRecHitLabel")),
       labelEE_(iConfig.getParameter<edm::InputTag>("EERecHitLabel")),
       labelHBHE_(iConfig.getParameter<edm::InputTag>("HBHERecHitLabel")),
       labelMuon_(iConfig.getParameter<edm::InputTag>("MuonLabel")),
       pMuonMin_(iConfig.getParameter<double>("MinimumMuonP")) {
   // define tokens for access
   tok_Vtx_ = consumes<reco::VertexCollection>(labelVtx_);
   tok_BS_ = consumes<reco::BeamSpot>(labelBS_);
   tok_EB_ = consumes<EcalRecHitCollection>(labelEB_);
   tok_EE_ = consumes<EcalRecHitCollection>(labelEE_);
   tok_HBHE_ = consumes<HBHERecHitCollection>(labelHBHE_);
   tok_Muon_ = consumes<reco::MuonCollection>(labelMuon_);
 
   edm::LogVerbatim("HcalHBHEMuon") << "Parameters read from config file \n"
                                    << "\t minP of muon " << pMuonMin_ << "\t input labels " << labelBS_ << " "
                                    << labelVtx_ << " " << labelEB_ << " " << labelEE_ << " " << labelHBHE_ << " "
                                    << labelMuon_;
 
   //saves the following collections
   produces<reco::BeamSpot>(labelBS_.label());
   produces<reco::VertexCollection>(labelVtx_.label());
   produces<EcalRecHitCollection>(labelEB_.instance());
   produces<EcalRecHitCollection>(labelEE_.instance());
   produces<HBHERecHitCollection>(labelHBHE_.label());
   produces<reco::MuonCollection>(labelMuon_.label());
 }

◆ ~AlCaHBHEMuonProducer()

AlCaHBHEMuonProducer::~AlCaHBHEMuonProducer ( )

override

Definition at line 112 of file AlCaHBHEMuonProducer.cc.

112 {}

Member Function Documentation

◆ endStream()

void AlCaHBHEMuonProducer::endStream ( )

override

Definition at line 212 of file AlCaHBHEMuonProducer.cc.

References nAll_, and nGood_.

                                      {
   globalCache()->nAll_ += nAll_;
   globalCache()->nGood_ += nGood_;
 }

◆ fillDescriptions()

void AlCaHBHEMuonProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 221 of file AlCaHBHEMuonProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                       {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("BeamSpotLabel", edm::InputTag("offlineBeamSpot"));
   desc.add<edm::InputTag>("VertexLabel", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("EBRecHitLabel", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
   desc.add<edm::InputTag>("EERecHitLabel", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
   desc.add<edm::InputTag>("HBHERecHitLabel", edm::InputTag("hbhereco"));
   desc.add<edm::InputTag>("MuonLabel", edm::InputTag("muons"));
   desc.add<double>("MinimumMuonP", 5.0);
   descriptions.add("alcaHBHEMuonProducer", desc);
 }

◆ globalEndJob()

void AlCaHBHEMuonProducer::globalEndJob ( const alCaHBHEMuonProducer::Counters * counters )

static

Definition at line 217 of file AlCaHBHEMuonProducer.cc.

References submitPVResolutionJobs::count.

                                                                                  {
   edm::LogVerbatim("HcalHBHEMuon") << "Finds " << count->nGood_ << " good tracks in " << count->nAll_ << " events";
 }

◆ initializeGlobalCache()

static std::unique_ptr<alCaHBHEMuonProducer::Counters> AlCaHBHEMuonProducer::initializeGlobalCache ( edm::ParameterSet const & )

inlinestatic

Definition at line 53 of file AlCaHBHEMuonProducer.cc.

                                                                                                    {
     return std::make_unique<alCaHBHEMuonProducer::Counters>();
   }

◆ produce()

void AlCaHBHEMuonProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 114 of file AlCaHBHEMuonProducer.cc.

References accept(), EcalCondDBWriter_cfi::beam, edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), photonIsolationHIProducer_cfi::hbhe, iEvent, edm::InputTag::instance(), edm::InputTag::label(), labelBS_, labelEB_, labelEE_, labelHBHE_, labelMuon_, labelVtx_, eostools::move(), HLT_2024v14_cff::muon, DiMuonV_cfg::muons, nAll_, nGood_, select(), tok_BS_, tok_EB_, tok_EE_, tok_HBHE_, tok_Muon_, tok_Vtx_, validateGeometry_cfg::valid, and L1BJetProducer_cff::vtx.

                                                                                 {
   ++nAll_;
   bool valid(true);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HcalHBHEMuon") << "AlCaHBHEMuonProducer::Run " << iEvent.id().run() << " Event "
                                    << iEvent.id().event() << " Luminosity " << iEvent.luminosityBlock() << " Bunch "
                                    << iEvent.bunchCrossing();
 #endif
 
   //Step1: Get all the relevant containers
   auto bmspot = iEvent.getHandle(tok_BS_);
   if (!bmspot.isValid()) {
     edm::LogWarning("HcalHBHEMuon") << "AlCaHBHEMuonProducer: Error! can't get product " << labelBS_;
     valid = false;
   }
 
   auto vt = iEvent.getHandle(tok_Vtx_);
   if (!vt.isValid()) {
     edm::LogWarning("HcalHBHEMuon") << "AlCaHBHEMuonProducer: Error! can't get product " << labelVtx_;
     valid = false;
   }
 
   auto barrelRecHitsHandle = iEvent.getHandle(tok_EB_);
   if (!barrelRecHitsHandle.isValid()) {
     edm::LogWarning("HcalHBHEMuon") << "AlCaHBHEMuonProducer: Error! can't get product " << labelEB_;
     valid = false;
   }
 
   auto endcapRecHitsHandle = iEvent.getHandle(tok_EE_);
   if (!endcapRecHitsHandle.isValid()) {
     edm::LogWarning("HcalHBHEMuon") << "AlCaHBHEMuonProducer: Error! can't get product " << labelEE_;
     valid = false;
   }
 
   auto hbhe = iEvent.getHandle(tok_HBHE_);
   if (!hbhe.isValid()) {
     edm::LogWarning("HcalHBHEMuon") << "AlCaHBHEMuonProducer: Error! can't get product " << labelHBHE_;
     valid = false;
   }
 
   auto muonhandle = iEvent.getHandle(tok_Muon_);
   if (!muonhandle.isValid()) {
     edm::LogWarning("HcalHBHEMuon") << "AlCaHBHEMuonProducer: Error! can't get product " << labelMuon_;
     valid = false;
   }
 
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HcalHBHEMuon") << "AlCaHBHEMuonProducer::obtained the collections with validity flag " << valid;
 #endif
 
   //For accepted events
   auto outputBeamSpot = std::make_unique<reco::BeamSpot>();
   auto outputVColl = std::make_unique<reco::VertexCollection>();
   auto outputEBColl = std::make_unique<EBRecHitCollection>();
   auto outputEEColl = std::make_unique<EERecHitCollection>();
   auto outputHBHEColl = std::make_unique<HBHERecHitCollection>();
   auto outputMColl = std::make_unique<reco::MuonCollection>();
 
   if (valid) {
     const reco::BeamSpot beam = *(bmspot.product());
     outputBeamSpot = std::make_unique<reco::BeamSpot>(
         beam.position(), beam.sigmaZ(), beam.dxdz(), beam.dydz(), beam.BeamWidthX(), beam.covariance(), beam.type());
     const reco::VertexCollection vtx = *(vt.product());
     const EcalRecHitCollection ebcoll = *(barrelRecHitsHandle.product());
     const EcalRecHitCollection eecoll = *(endcapRecHitsHandle.product());
     const HBHERecHitCollection hbhecoll = *(hbhe.product());
     const reco::MuonCollection muons = *(muonhandle.product());
 
     bool accept = select(muons);
 
     if (accept) {
       ++nGood_;
 
       for (reco::VertexCollection::const_iterator vtr = vtx.begin(); vtr != vtx.end(); ++vtr)
         outputVColl->push_back(*vtr);
 
       for (edm::SortedCollection<EcalRecHit>::const_iterator ehit = ebcoll.begin(); ehit != ebcoll.end(); ++ehit)
         outputEBColl->push_back(*ehit);
 
       for (edm::SortedCollection<EcalRecHit>::const_iterator ehit = eecoll.begin(); ehit != eecoll.end(); ++ehit)
         outputEEColl->push_back(*ehit);
 
       for (std::vector<HBHERecHit>::const_iterator hhit = hbhecoll.begin(); hhit != hbhecoll.end(); ++hhit)
         outputHBHEColl->push_back(*hhit);
 
       for (reco::MuonCollection::const_iterator muon = muons.begin(); muon != muons.end(); ++muon)
         outputMColl->push_back(*muon);
     }
   }
 
   iEvent.put(std::move(outputBeamSpot), labelBS_.label());
   iEvent.put(std::move(outputVColl), labelVtx_.label());
   iEvent.put(std::move(outputEBColl), labelEB_.instance());
   iEvent.put(std::move(outputEEColl), labelEE_.instance());
   iEvent.put(std::move(outputHBHEColl), labelHBHE_.label());
   iEvent.put(std::move(outputMColl), labelMuon_.label());
 }

◆ select()

bool AlCaHBHEMuonProducer::select ( const reco::MuonCollection & muons )

private

Definition at line 235 of file AlCaHBHEMuonProducer.cc.

References dqmdumpme::k, DiMuonV_cfg::muons, convertSQLiteXML::ok, AlCaHLTBitMon_ParallelJobs::p, and pMuonMin_.

Referenced by produce().

                                                                  {
   bool ok(false);
   for (unsigned int k = 0; k < muons.size(); ++k) {
     if (muons[k].p() > pMuonMin_) {
       ok = true;
       break;
     }
   }
   return ok;
 }