#include <L3TkMuonProducer.h>

Inheritance diagram for L3TkMuonProducer:

Public Types
typedef edm::Ref< L3MuonTrajectorySeedCollection >	SeedRef

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

Public Member Functions
	L3TkMuonProducer (const edm::ParameterSet &)
	constructor with config More...

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

	~L3TkMuonProducer () override
	destructor More...

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 Types
typedef std::map< pseudoRef, std::pair< reco::TrackRef, SeedRef > >	LXtoL3sMap

typedef std::pair< unsigned int, unsigned int >	pseudoRef

Private Member Functions
pseudoRef	makePseudoRef (const L3MuonTrajectorySeed &s)

bool	sharedSeed (const L3MuonTrajectorySeed &s1, const L3MuonTrajectorySeed &s2)

Static Private Member Functions
static bool	seedRefBypT (const SeedRef &s1, const SeedRef &s2)

static bool	trackRefBypT (const reco::TrackRef &t1, const reco::TrackRef &t2)

Private Attributes
edm::InputTag	theL3CollectionLabel

edm::EDGetTokenT< reco::TrackCollection >	trackToken_

Detailed Description

This module creates a skimed list of reco::Track (pointing to the original TrackExtra and TrackingRecHitOwnedVector One highest pT track per L1/L2 is selected, requiring some quality.

Author: J-R Vlimant.

Definition at line 27 of file L3TkMuonProducer.h.

Member Typedef Documentation

◆ LXtoL3sMap

typedef std::map<pseudoRef, std::pair<reco::TrackRef, SeedRef> > L3TkMuonProducer::LXtoL3sMap

private

Definition at line 47 of file L3TkMuonProducer.h.

◆ pseudoRef

typedef std::pair<unsigned int, unsigned int> L3TkMuonProducer::pseudoRef

private

Definition at line 46 of file L3TkMuonProducer.h.

◆ SeedRef

typedef edm::Ref<L3MuonTrajectorySeedCollection> L3TkMuonProducer::SeedRef

Definition at line 38 of file L3TkMuonProducer.h.

Constructor & Destructor Documentation

◆ L3TkMuonProducer()

L3TkMuonProducer::L3TkMuonProducer ( const edm::ParameterSet & parameterSet )

constructor with config

Definition at line 26 of file L3TkMuonProducer.cc.

References edm::ParameterSet::getParameter(), triggerObjects_cff::id, LogTrace, edm::BranchDescription::moduleLabel(), edm::parameterSet(), edm::BranchDescription::processName(), edm::BranchDescription::productInstanceName(), and edm::BranchDescription::unwrappedTypeID().

                                                                    {
   LogTrace("Muon|RecoMuon|L3TkMuonProducer") << " constructor called";
 
   // StandAlone Collection Label
   theL3CollectionLabel = parameterSet.getParameter<InputTag>("InputObjects");
   trackToken_ = consumes<reco::TrackCollection>(theL3CollectionLabel);
   produces<TrackCollection>();
   produces<TrackExtraCollection>();
   produces<TrackingRecHitCollection>();
 
   callWhenNewProductsRegistered([this](const edm::BranchDescription& iBD) {
     edm::TypeID id(typeid(L3MuonTrajectorySeedCollection));
     if (iBD.unwrappedTypeID() == id) {
       this->mayConsume<L3MuonTrajectorySeedCollection>(
           edm::InputTag{iBD.moduleLabel(), iBD.productInstanceName(), iBD.processName()});
     }
   });
 }

◆ ~L3TkMuonProducer()

L3TkMuonProducer::~L3TkMuonProducer ( )

override

destructor

Definition at line 46 of file L3TkMuonProducer.cc.

References LogTrace.

                                     {
   LogTrace("Muon|RecoMuon|L3TkMuonProducer") << " L3TkMuonProducer destructor called";
 }

Member Function Documentation

◆ makePseudoRef()

pseudoRef L3TkMuonProducer::makePseudoRef ( const L3MuonTrajectorySeed & s )

inlineprivate

Definition at line 49 of file L3TkMuonProducer.h.

References edm::ProductID::id(), edm::Ref< C, T, F >::id(), edm::Ref< C, T, F >::isNull(), edm::Ref< C, T, F >::key(), and alignCSCRings::s.

                                                          {
     reco::TrackRef l2ref = s.l2Track();
     if (l2ref.isNull()) {
       l1extra::L1MuonParticleRef l1ref = s.l1Particle();
       return std::make_pair(l1ref.id().id(), l1ref.key());
     } else
       return std::make_pair(l2ref.id().id(), l2ref.key());
   }

◆ produce()

void L3TkMuonProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

override

produce candidates

reconstruct muons

Definition at line 108 of file L3TkMuonProducer.cc.

References TrajectorySeed::direction(), f, mps_fire::i, edm::ProductID::id(), edm::Ref< C, T, F >::id(), reco::Track::innerDetId(), reco::Track::innerMomentum(), reco::Track::innerOk(), reco::Track::innerPosition(), reco::Track::innerStateCovariance(), edm::Ref< C, T, F >::key(), LogDebug, findQualityFiles::maxI, metname, edm::StableProvenance::moduleLabel(), eostools::move(), reco::Track::outerDetId(), reco::Track::outerMomentum(), reco::Track::outerOk(), reco::Track::outerPosition(), reco::Track::outerStateCovariance(), printseed(), printvector(), edm::StableProvenance::processName(), edm::StableProvenance::productInstanceName(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), fileCollector::seed, jetUpdater_cfi::sort, and tracks.

                                                                          {
   const string metname = "Muon|RecoMuon|L3TkMuonProducer";
 
   // Take the L3 container
   LogDebug(metname) << " Taking the L3/GLB muons: " << theL3CollectionLabel.label();
   Handle<TrackCollection> tracks;
   event.getByToken(trackToken_, tracks);
 
   //make the LX->L3s pools
   LXtoL3sMap LXtoL3s;
 
   unsigned int maxI = tracks->size();
   bool gotL3seeds = false;
   edm::Handle<L3MuonTrajectorySeedCollection> l3seeds;
 
   //make a list of reference to tracker tracks
   vector<TrackRef> orderedTrackTracks(maxI);
   for (unsigned int i = 0; i != maxI; i++)
     orderedTrackTracks[i] = TrackRef(tracks, i);
   LogDebug(metname) << "vector of L3 tracks before ordering:\n" << printvector(orderedTrackTracks);
   //order them in pT
   sort(orderedTrackTracks.begin(), orderedTrackTracks.end(), trackRefBypT);
   LogDebug(metname) << "vector of L3 tracks after ordering:\n" << printvector(orderedTrackTracks);
   //loop over then
   for (unsigned int i = 0; i != maxI; i++) {
     TrackRef& tk = orderedTrackTracks[i];
     SeedRef l3seedRef = tk->seedRef().castTo<SeedRef>();
 
     vector<SeedRef> allPossibleOrderedLx;  // with identical hit-set
     //add the direct relation
     allPossibleOrderedLx.push_back(l3seedRef);
     LogDebug(metname) << "adding the seed ref: " << l3seedRef.id().id() << ":" << l3seedRef.key()
                       << " for this tracker track: " << tk.id().id() << ":" << tk.key();
 
     //add the relations due to shared seeds
     //check whether there is a "shared" seed in addition
     if (!gotL3seeds) {
       //need to fetch the handle from the ref
       const edm::StableProvenance& seedsProv = event.getStableProvenance(l3seedRef.id());
       edm::InputTag l3seedsTag(seedsProv.moduleLabel(), seedsProv.productInstanceName(), seedsProv.processName());
       event.getByLabel(l3seedsTag, l3seeds);
       gotL3seeds = true;
       LogDebug(metname) << "got seeds handle from: " << l3seedsTag;
     }
     //loop the other seeds in the collection
     for (unsigned int iS = 0; iS != l3seeds->size(); ++iS) {
       const L3MuonTrajectorySeed& seed = (*l3seeds)[iS];
       const L3MuonTrajectorySeed& thisSeed = *l3seedRef;
       if (l3seedRef.key() == iS)
         continue;  //not care about this one
       //compare this seed with the seed in the collection
       if (sharedSeed(seed, thisSeed)) {
         SeedRef thisSharedSeedRef(l3seeds, iS);
         LogDebug(metname) << "shared seeds: \n"
                           << printseed(l3seedRef) << " and: \n"
                           << printseed(thisSharedSeedRef)
                           << "\nadding ANOTHER seed ref: " << thisSharedSeedRef.id().id() << ":"
                           << thisSharedSeedRef.key() << " for this tracker track: " << tk.id().id() << ":" << tk.key();
         //  edm::LogError(metname)<<" we have a shared seed right there.";
         allPossibleOrderedLx.push_back(thisSharedSeedRef);
       }  //seed is shared
     }    //loop all other existing seed for overlaps
 
     //now you have the full list of Lx objects that have seed this tracker track.
     // order the list in pT of Lx objects
     LogDebug(metname) << "list of possible Lx objects for tracker track: " << tk.id().id() << ":" << tk.key()
                       << " before ordering\n"
                       << printvector(allPossibleOrderedLx);
     sort(allPossibleOrderedLx.begin(), allPossibleOrderedLx.end(), seedRefBypT);
     LogDebug(metname) << "list of possible Lx objects for tracker track: " << tk.id().id() << ":" << tk.key()
                       << " after ordering\n"
                       << printvector(allPossibleOrderedLx);
     // assign this tracker track to the highest pT Lx.
     for (unsigned int iL = 0; iL != allPossibleOrderedLx.size(); ++iL) {
       SeedRef thisRef = allPossibleOrderedLx[iL];
       pseudoRef ref = makePseudoRef(*thisRef);
       LogDebug(metname) << "seed ref: " << thisRef.id().id() << ":" << thisRef.key()
                         << " transcribe to pseudoref: " << ref.first << ":" << ref.second;
       LXtoL3sMap::iterator f = LXtoL3s.find(ref);
       if (f != LXtoL3s.end()) {
         //there's already an entry. because of the prior ordering in pT of the tracker track refs
         // the track ref already there *has* a higher pT: this one cannot compete and should be assigned to the next Lx;
         LogDebug(metname) << "this tracker track: " << tk.id().id() << ":" << tk.key() << " (" << tk->pt() << ")"
                           << "\n cannot compete in pT with track: " << f->second.first.id().id() << ":"
                           << f->second.first.key() << " (" << f->second.first->pt() << ")"
                           << "\n already assigned to pseudo ref: " << ref.first << ":" << ref.second
                           << " which corresponds to seedRef: " << f->second.second.id().id() << ":"
                           << f->second.second.key();
         continue;
       } else {
         //there was no entry yet. make the assignement
         LogDebug(metname) << "this tracker track: " << tk.id().id() << ":" << tk.key()
                           << " is assigned to pseudo ref: " << ref.first << ":" << ref.second
                           << " which corresponds to seedRef: " << thisRef.id().id() << ":" << thisRef.key();
         LXtoL3s[ref] = std::make_pair(tk, thisRef);
         //once assigned. break
         break;
       }
     }  //loop possible Lx for possible assignement
   }    //loop over ordered list of tracker track refs
 
   //prepare the output
   auto outTracks = std::make_unique<TrackCollection>(LXtoL3s.size());
   auto outTrackExtras = std::make_unique<TrackExtraCollection>(LXtoL3s.size());
   reco::TrackExtraRefProd rTrackExtras = event.getRefBeforePut<TrackExtraCollection>();
   auto outRecHits = std::make_unique<TrackingRecHitCollection>();
   TrackingRecHitRefProd rHits = event.getRefBeforePut<TrackingRecHitCollection>();
 
   LogDebug(metname) << "reading the map to make " << LXtoL3s.size() << "products.";
   //fill the collection from the map
   LXtoL3sMap::iterator f = LXtoL3s.begin();
   unsigned int i = 0;
   for (; f != LXtoL3s.end(); ++f, ++i) {
     LogDebug(metname) << "copy the track over, and make ref to extra";
     const Track& trk = *(f->second.first);
     (*outTracks)[i] = Track(trk);
     (*outTracks)[i].setExtra(TrackExtraRef(rTrackExtras, i));
 
     LogDebug(metname) << "copy the trackExtra too, and change the seedref";
     edm::RefToBase<TrajectorySeed> seedRef(f->second.second);
     //do not use the copy constructor, otherwise the hit Ref are still the same
     (*outTrackExtras)[i] = TrackExtra(trk.outerPosition(),
                                       trk.outerMomentum(),
                                       trk.outerOk(),
                                       trk.innerPosition(),
                                       trk.innerMomentum(),
                                       trk.innerOk(),
                                       trk.outerStateCovariance(),
                                       trk.outerDetId(),
                                       trk.innerStateCovariance(),
                                       trk.innerDetId(),
                                       seedRef->direction(),
                                       seedRef);
 
     LogDebug(metname) << "copy the hits too";
     unsigned int iRH = 0;
     for (trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++hit, ++iRH) {
       outRecHits->push_back((*hit)->clone());
     }
     (*outTrackExtras)[i].setHits(rHits, 0, iRH);
   }
 
   LogDebug(metname) << "made: " << outTracks->size() << " tracks, " << outTrackExtras->size() << " extras and "
                     << outRecHits->size() << " rechits.";
 
   //put the collection in the event
   LogDebug(metname) << "loading...";
   event.put(std::move(outTracks));
   event.put(std::move(outTrackExtras));
   event.put(std::move(outRecHits));
   LogDebug(metname) << " Event loaded"
                     << "================================";
 }

◆ seedRefBypT()

static bool L3TkMuonProducer::seedRefBypT	(	const SeedRef &	s1,
		const SeedRef &	s2
	)

inlinestaticprivate

Definition at line 61 of file L3TkMuonProducer.h.

References edm::Ref< C, T, F >::isNull(), HLT_2022v12_cff::pt1, and HLT_2022v12_cff::pt2.

                                                                 {
     double pt1, pt2;
     reco::TrackRef l2ref1 = s1->l2Track();
     if (l2ref1.isNull())
       pt1 = s1->l1Particle()->pt();
     else
       pt1 = l2ref1->pt();
     reco::TrackRef l2ref2 = s2->l2Track();
     if (l2ref2.isNull())
       pt2 = s2->l1Particle()->pt();
     else
       pt2 = l2ref2->pt();
     return (pt1 > pt2);
   }

◆ sharedSeed()

bool L3TkMuonProducer::sharedSeed	(	const L3MuonTrajectorySeed &	s1,
		const L3MuonTrajectorySeed &	s2
	)

private

Definition at line 50 of file L3TkMuonProducer.cc.

References TrackingRecHit::all, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, TrajectorySeed::nHits(), diffTwoXMLs::r1, diffTwoXMLs::r2, and TrajectorySeed::recHits().

                                                                                                 {
   //quit right away on nH=0
   if (s1.nHits() == 0 || s2.nHits() == 0)
     return false;
   //quit right away if not the same number of hits
   if (s1.nHits() != s2.nHits())
     return false;
   auto const& r1 = s1.recHits();
   auto const& r2 = s2.recHits();
   //quit right away if first detId does not match. front exist because of ==0 ->quit test
   if (r1.begin()->geographicalId() != r2.begin()->geographicalId())
     return false;
   //then check hit by hit if they are the same
   for (auto i1 = r1.begin(), i2 = r2.begin(); i1 != r1.end() && i2 != r2.end(); ++i1, ++i2) {
     if (!i1->sharesInput(&(*i2), TrackingRecHit::all))
       return false;
   }
   return true;
 }