#include <TSGFromL1Muon.h>

Inheritance diagram for TSGFromL1Muon:

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

	TSGFromL1Muon (const edm::ParameterSet &cfg)

	~TSGFromL1Muon () 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

Private Attributes
edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	theFieldToken

edm::EDGetTokenT< PixelTrackFilter >	theFilterToken

std::unique_ptr< L1MuonPixelTrackFitter >	theFitter

std::unique_ptr< OrderedHitsGenerator >	theHitGenerator

std::unique_ptr< L1MuonSeedsMerger >	theMerger

std::unique_ptr< L1MuonRegionProducer >	theRegionProducer

const SeedFromProtoTrack::Config	theSFPTConfig

edm::InputTag	theSourceTag

edm::EDGetTokenT< l1extra::L1MuonParticleCollection >	theSourceToken

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

Description: EDPRoducer to generate L3MuonTracjectorySeed from L1MuonParticles

Author: Marcin Konecki

Definition at line 28 of file TSGFromL1Muon.h.

Constructor & Destructor Documentation

◆ TSGFromL1Muon()

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

Definition at line 43 of file TSGFromL1Muon.cc.

References looper::cfg, get, edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, theFilterToken, theFitter, theHitGenerator, theMerger, theRegionProducer, theSourceTag, and theSourceToken.

     : theFieldToken(esConsumes()), theSFPTConfig(consumesCollector()) {
   produces<L3MuonTrajectorySeedCollection>();
   theSourceTag = cfg.getParameter<edm::InputTag>("L1MuonLabel");
 
   edm::ConsumesCollector iC = consumesCollector();
   theFilterToken = consumes<PixelTrackFilter>(cfg.getParameter<edm::InputTag>("Filter"));
 
   edm::ParameterSet hitsfactoryPSet = cfg.getParameter<edm::ParameterSet>("OrderedHitsFactoryPSet");
   std::string hitsfactoryName = hitsfactoryPSet.getParameter<std::string>("ComponentName");
   theHitGenerator = OrderedHitsGeneratorFactory::get()->create(hitsfactoryName, hitsfactoryPSet, iC);
 
   theSourceToken = iC.consumes<L1MuonParticleCollection>(theSourceTag);
 
   theRegionProducer =
       std::make_unique<L1MuonRegionProducer>(cfg.getParameter<edm::ParameterSet>("RegionFactoryPSet"), iC);
   theFitter = std::make_unique<L1MuonPixelTrackFitter>(cfg.getParameter<edm::ParameterSet>("FitterPSet"));
 
   edm::ParameterSet cleanerPSet = cfg.getParameter<edm::ParameterSet>("CleanerPSet");
   theMerger = std::make_unique<L1MuonSeedsMerger>(cleanerPSet);
 }

◆ ~TSGFromL1Muon()

TSGFromL1Muon::~TSGFromL1Muon ( )

overridedefault

Member Function Documentation

◆ produce()

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

override

Definition at line 67 of file TSGFromL1Muon.cc.

References HLT_2022v15_cff::candidates, makeMEIFBenchmarkPlots::ev, ALCARECOTkAlBeamHalo_cff::filter, edm::EventSetup::getData(), hfClusterShapes_cfi::hits, mps_fire::i, LogDebug, eostools::move(), nHits, HLT_2022v15_cff::region, SiPixelRawToDigiRegional_cfi::Regions, mps_fire::result, fileCollector::seed, theFieldToken, theFilterToken, theFitter, theHitGenerator, theMerger, theRegionProducer, theSFPTConfig, theSourceToken, HLT_2022v15_cff::track, and tracks.

                                                                  {
   auto result = std::make_unique<L3MuonTrajectorySeedCollection>();
 
   edm::Handle<L1MuonParticleCollection> l1muon;
   ev.getByToken(theSourceToken, l1muon);
 
   edm::Handle<PixelTrackFilter> hfilter;
   ev.getByToken(theFilterToken, hfilter);
   const PixelTrackFilter& filter = *hfilter;
 
   const auto& field = es.getData(theFieldToken);
   LogDebug("TSGFromL1Muon") << l1muon->size() << " l1 muons to seed from.";
 
   L1MuonParticleCollection::const_iterator muItr = l1muon->begin();
   L1MuonParticleCollection::const_iterator muEnd = l1muon->end();
   for (size_t iL1 = 0; muItr < muEnd; ++muItr, ++iL1) {
     if (muItr->gmtMuonCand().empty())
       continue;
 
     const L1MuGMTCand& muon = muItr->gmtMuonCand();
     l1extra::L1MuonParticleRef l1Ref(l1muon, iL1);
 
     theRegionProducer->setL1Constraint(muon);
     theFitter->setL1Constraint(muon);
 
     typedef std::vector<std::unique_ptr<TrackingRegion> > Regions;
     Regions regions = theRegionProducer->regions(es);
     for (Regions::const_iterator ir = regions.begin(); ir != regions.end(); ++ir) {
       L1MuonSeedsMerger::TracksAndHits tracks;
       const TrackingRegion& region = **ir;
       const OrderedSeedingHits& candidates = theHitGenerator->run(region, ev, es);
 
       unsigned int nSets = candidates.size();
       for (unsigned int ic = 0; ic < nSets; ic++) {
         const SeedingHitSet& hits = candidates[ic];
         std::vector<const TrackingRecHit*> trh;
         for (unsigned int i = 0, nHits = hits.size(); i < nHits; ++i)
           trh.push_back(hits[i]->hit());
 
         theFitter->setPxConstraint(hits);
         reco::Track* track = theFitter->run(field, trh, region);
         if (!track)
           continue;
 
         if (!filter(track, trh)) {
           delete track;
           continue;
         }
         tracks.push_back(L1MuonSeedsMerger::TrackAndHits(track, hits));
       }
 
       if (theMerger)
         theMerger->resolve(tracks);
       for (L1MuonSeedsMerger::TracksAndHits::const_iterator it = tracks.begin(); it != tracks.end(); ++it) {
         SeedFromProtoTrack seed(theSFPTConfig, *(it->first), it->second, es);
         if (seed.isValid())
           (*result).push_back(L3MuonTrajectorySeed(seed.trajectorySeed(), l1Ref));
 
         //      GlobalError vtxerr( sqr(region->originRBound()), 0, sqr(region->originRBound()),
         //                                               0, 0, sqr(region->originZBound()));
         //      SeedFromConsecutiveHits seed( candidates[ic],region->origin(), vtxerr, es);
         //      if (seed.isValid()) (*result).push_back( seed.TrajSeed() );
         delete it->first;
       }
     }
   }
 
   LogDebug("TSGFromL1Muon") << result->size() << " seeds to the event.";
   ev.put(std::move(result));
 }