#include <HIMuonTrackingRegionProducer.h>

Inheritance diagram for HIMuonTrackingRegionProducer:

Public Member Functions
	HIMuonTrackingRegionProducer (const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)

std::vector< std::unique_ptr< TrackingRegion > >	regions (const edm::Event &ev, const edm::EventSetup &es) const override

	~HIMuonTrackingRegionProducer () override

Public Member Functions inherited from TrackingRegionProducer
virtual	~TrackingRegionProducer ()

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

Private Attributes
edm::InputTag	theMuonSource

edm::EDGetTokenT< reco::TrackCollection >	theMuonSourceToken

MuonTrackingRegionBuilder *	theRegionBuilder

MuonServiceProxy *	theService

Detailed Description

Definition at line 18 of file HIMuonTrackingRegionProducer.h.

Constructor & Destructor Documentation

HIMuonTrackingRegionProducer::HIMuonTrackingRegionProducer	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC
	)

inline

Definition at line 20 of file HIMuonTrackingRegionProducer.h.

References edm::ParameterSet::getParameter(), MuonServiceProxy_cff::MuonServiceProxy, HLT_2018_cff::MuonTrackingRegionBuilder, theMuonSource, theMuonSourceToken, theRegionBuilder, and theService.

                                                                                       {
     // get parameters from PSet
     theMuonSource = cfg.getParameter<edm::InputTag>("MuonSrc");
     theMuonSourceToken = iC.consumes<reco::TrackCollection>(theMuonSource);
 
     // initialize region builder
     edm::ParameterSet regionBuilderPSet = cfg.getParameter<edm::ParameterSet>("MuonTrackingRegionBuilder");
     theRegionBuilder = new MuonTrackingRegionBuilder(regionBuilderPSet, iC);
 
     // initialize muon service proxy
     edm::ParameterSet servicePSet = cfg.getParameter<edm::ParameterSet>("ServiceParameters");
     theService = new MuonServiceProxy(servicePSet);
   }

HIMuonTrackingRegionProducer::~HIMuonTrackingRegionProducer ( )

inlineoverride

Definition at line 34 of file HIMuonTrackingRegionProducer.h.

34 {}

Member Function Documentation

static void HIMuonTrackingRegionProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 36 of file HIMuonTrackingRegionProducer.h.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), MuonTrackingRegionBuilder::fillDescriptionsOffline(), HLT_2018_cff::InputTag, and edm::ParameterSetDescription::setAllowAnything().

                                                                            {
     edm::ParameterSetDescription desc;
 
     desc.add<edm::InputTag>("MuonSrc", edm::InputTag(""));
 
     edm::ParameterSetDescription descRegion;
     MuonTrackingRegionBuilder::fillDescriptionsOffline(descRegion);
     desc.add("MuonTrackingRegionBuilder", descRegion);
 
     edm::ParameterSetDescription descService;
     descService.setAllowAnything();
     desc.add<edm::ParameterSetDescription>("ServiceParameters", descService);
 
     descriptions.add("HiTrackingRegionEDProducer", desc);
   }

std::vector<std::unique_ptr<TrackingRegion> > HIMuonTrackingRegionProducer::regions	(	const edm::Event &	ev,
		const edm::EventSetup &	es
	)		const

inlineoverridevirtual

Implements TrackingRegionProducer.

Definition at line 52 of file HIMuonTrackingRegionProducer.h.

References edm::Event::getByToken(), jets_cff::nMuons, MuonTrackingRegionBuilder::region(), mps_fire::result, MuonTrackingRegionBuilder::setEvent(), theMuonSourceToken, theRegionBuilder, theService, and MuonServiceProxy::update().

                                                                                                 {
     // initialize output vector of tracking regions
     std::vector<std::unique_ptr<TrackingRegion> > result;
 
     // initialize the region builder
     theService->update(es);
     theRegionBuilder->setEvent(ev);
 
     // get stand-alone muon collection
     edm::Handle<reco::TrackCollection> muonH;
     ev.getByToken(theMuonSourceToken, muonH);
 
     // loop over all muons and add a tracking region for each
     // that passes the requirements specified to theRegionBuilder
     unsigned int nMuons = muonH->size();
     //std::cout << "there are " << nMuons << " muon(s)" << std::endl;
 
     // TO DO: this can be extended further to a double-loop
     // over all combinations of muons, returning tracking regions
     // for pairs that pass some loose invariant mass cuts
     for (unsigned int imu = 0; imu < nMuons; imu++) {
       reco::TrackRef muRef(muonH, imu);
       //std::cout << "muon #" << imu << ": pt=" << muRef->pt() << std::endl;
       result.push_back(theRegionBuilder->region(muRef));
     }
 
     return result;
   }