#include <TSGFromL2Muon.h>

Inheritance diagram for TSGFromL2Muon:

Public Member Functions
void	beginRun (const edm::Run &run, const edm::EventSetup &es) override

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

	TSGFromL2Muon (const edm::ParameterSet &cfg)

	~TSGFromL2Muon () override

Public Member Functions inherited from edm::stream::EDProducer<>
	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)

Private Attributes
edm::EDGetTokenT< reco::TrackCollection >	l2muonToken

edm::InputTag	theL2CollectionLabel

double	thePCut

double	thePtCut

std::unique_ptr< MuonTrackingRegionBuilder >	theRegionBuilder

std::unique_ptr< TrackerSeedCleaner >	theSeedCleaner

std::unique_ptr< MuonServiceProxy >	theService

std::unique_ptr< TrackerSeedGenerator >	theTkSeedGenerator

edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	theTTopoToken

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
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 25 of file TSGFromL2Muon.h.

Constructor & Destructor Documentation

◆ TSGFromL2Muon()

TSGFromL2Muon::TSGFromL2Muon ( const edm::ParameterSet & cfg )

Definition at line 10 of file TSGFromL2Muon.cc.

References looper::cfg, edm::ParameterSet::empty(), deDxTools::esConsumes(), get, edm::ParameterSet::getParameter(), l2muonToken, MuonServiceProxy::RunAndEvent, AlCaHLTBitMon_QueryRunRegistry::string, theL2CollectionLabel, thePCut, thePtCut, theRegionBuilder, theSeedCleaner, theService, theTkSeedGenerator, and theTTopoToken.

                                                        {
   produces<L3MuonTrajectorySeedCollection>();
 
   edm::ConsumesCollector iC = consumesCollector();
 
   edm::ParameterSet serviceParameters = cfg.getParameter<edm::ParameterSet>("ServiceParameters");
   theService = std::make_unique<MuonServiceProxy>(
       serviceParameters, consumesCollector(), MuonServiceProxy::UseEventSetupIn::RunAndEvent);
 
   //Pt and P cuts
   thePtCut = cfg.getParameter<double>("PtCut");
   thePCut = cfg.getParameter<double>("PCut");
 
   //Region builder
   edm::ParameterSet regionBuilderPSet = cfg.getParameter<edm::ParameterSet>("MuonTrackingRegionBuilder");
   //ability to no define a region
   if (!regionBuilderPSet.empty()) {
     theRegionBuilder = std::make_unique<MuonTrackingRegionBuilder>(regionBuilderPSet, iC);
   }
 
   //Seed generator
   edm::ParameterSet seedGenPSet = cfg.getParameter<edm::ParameterSet>("TkSeedGenerator");
   std::string seedGenName = seedGenPSet.getParameter<std::string>("ComponentName");
   theTkSeedGenerator = TrackerSeedGeneratorFactory::get()->create(seedGenName, seedGenPSet, iC);
 
   //Seed cleaner
   edm::ParameterSet trackerSeedCleanerPSet = cfg.getParameter<edm::ParameterSet>("TrackerSeedCleaner");
   //To activate or not the cleaner
   if (!trackerSeedCleanerPSet.empty()) {
     theSeedCleaner = std::make_unique<TrackerSeedCleaner>(trackerSeedCleanerPSet, iC);
   }
 
   //L2 collection
   theL2CollectionLabel = cfg.getParameter<edm::InputTag>("MuonCollectionLabel");
   l2muonToken = consumes<reco::TrackCollection>(theL2CollectionLabel);
 
   theTTopoToken = esConsumes();
 }

◆ ~TSGFromL2Muon()

TSGFromL2Muon::~TSGFromL2Muon ( )

overridedefault

Member Function Documentation

◆ beginRun()

void TSGFromL2Muon::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	es
	)

override

Definition at line 51 of file TSGFromL2Muon.cc.

References theSeedCleaner, theService, and theTkSeedGenerator.

                                                                        {
   //update muon proxy service
   bool duringEvent = false;
   theService->update(es, duringEvent);
   theTkSeedGenerator->init(theService.get());
   if (theSeedCleaner)
     theSeedCleaner->init(theService.get());
 }

◆ fillDescriptions()

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

static

Definition at line 125 of file TSGFromL2Muon.cc.

References submitPVResolutionJobs::desc.

                                                                                {
   edm::ParameterSetDescription desc;
   desc.setAllowAnything();
 }

◆ produce()

void TSGFromL2Muon::produce	(	edm::Event &	ev,
		const edm::EventSetup &	es
	)

override

Definition at line 60 of file TSGFromL2Muon.cc.

References makeMEIFBenchmarkPlots::ev, edm::EventSetup::getData(), l2muonToken, LogDebug, eostools::move(), HLT_2022v15_cff::region, mps_fire::result, thePCut, thePtCut, theRegionBuilder, theSeedCleaner, theService, theTkSeedGenerator, and theTTopoToken.

                                                                  {
   auto result = std::make_unique<L3MuonTrajectorySeedCollection>();
 
   //Retrieve tracker topology from geometry
   const TrackerTopology* tTopo = &es.getData(theTTopoToken);
 
   //intialize tools
   theService->update(es);
   theTkSeedGenerator->setEvent(ev);
   if (theRegionBuilder)
     theRegionBuilder->setEvent(ev, es);
   if (theSeedCleaner)
     theSeedCleaner->setEvent(ev);
 
   //retrieve L2 track collection
   edm::Handle<reco::TrackCollection> l2muonH;
   ev.getByToken(l2muonToken, l2muonH);
 
   // produce trajectory seed collection
   LogDebug("TSGFromL2Muon") << l2muonH->size() << " l2 tracks.";
 
   for (unsigned int imu = 0; imu != l2muonH->size(); ++imu) {
     //make a ref to l2 muon
     reco::TrackRef muRef(l2muonH, imu);
 
     // cut on muons with low momenta
     if (muRef->pt() < thePtCut || muRef->innerMomentum().Rho() < thePtCut || muRef->innerMomentum().R() < thePCut)
       continue;
 
     //define the region of interest
     std::unique_ptr<RectangularEtaPhiTrackingRegion> region;
     if (theRegionBuilder) {
       region = theRegionBuilder->region(muRef);
     } else {
       region = std::make_unique<RectangularEtaPhiTrackingRegion>();
     }
 
     //Make seeds container
     std::vector<TrajectorySeed> tkSeeds;
 
     //Make TrackCand
     std::pair<const Trajectory*, reco::TrackRef> staCand((Trajectory*)nullptr, muRef);
 
     //Run seed generator to fill seed container
     theTkSeedGenerator->trackerSeeds(staCand, *region, tTopo, tkSeeds);
 
     //Seed Cleaner From Direction
     if (theSeedCleaner) {
       theSeedCleaner->clean(muRef, *region, tkSeeds);
     }
 
     for (unsigned int is = 0; is != tkSeeds.size(); ++is) {
       result->push_back(L3MuonTrajectorySeed(tkSeeds[is], muRef));
     }
   }
 
   //ADDME: remove seed duplicate, keeping the ref to L2
 
   LogDebug("TSGFromL2Muon") << result->size() << " trajectory seeds to the events";
 
   //put in the event
   ev.put(std::move(result));
 }