Inheritance diagram for TrackCandidateProducer:

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

	TrackCandidateProducer (const edm::ParameterSet &conf)

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::EDGetTokenT< std::vector < bool > >	hitMasksToken

FastTrackerRecHitSplitter	hitSplitter

const edm::ESGetToken < MagneticField, IdealMagneticFieldRecord >	magneticFieldESToken_

double	maxSeedMatchEstimator

const edm::ESGetToken < Propagator, TrackingComponentsRecord >	propagatorESToken_

std::string	propagatorLabel

edm::EDGetTokenT < FastTrackerRecHitCombinationCollection >	recHitCombinationsToken

bool	rejectOverlaps

edm::EDGetTokenT< edm::View < TrajectorySeed > >	seedToken

edm::EDGetTokenT < edm::SimTrackContainer >	simTrackToken

bool	splitHits

const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeometryESToken_

const edm::ESGetToken < TrackerTopology, TrackerTopologyRcd >	trackerTopologyESToken_

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 42 of file TrackCandidateProducer.cc.

Constructor & Destructor Documentation

TrackCandidateProducer::TrackCandidateProducer ( const edm::ParameterSet & conf )

explicit

Definition at line 67 of file TrackCandidateProducer.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hitMasksToken, maxSeedMatchEstimator, recHitCombinationsToken, rejectOverlaps, seedToken, simTrackToken, and splitHits.

     : propagatorLabel(conf.getParameter<std::string>("propagator")),
       magneticFieldESToken_(esConsumes()),
       trackerGeometryESToken_(esConsumes()),
       trackerTopologyESToken_(esConsumes()),
       propagatorESToken_(esConsumes(edm::ESInputTag("", propagatorLabel))),
       hitSplitter() {
   // produces
   produces<TrackCandidateCollection>();
 
   // consumes
   if (conf.exists("hitMasks")) {
     hitMasksToken = consumes<std::vector<bool> >(conf.getParameter<edm::InputTag>("hitMasks"));
   }
   seedToken = consumes<edm::View<TrajectorySeed> >(conf.getParameter<edm::InputTag>("src"));
   recHitCombinationsToken =
       consumes<FastTrackerRecHitCombinationCollection>(conf.getParameter<edm::InputTag>("recHitCombinations"));
   simTrackToken = consumes<edm::SimTrackContainer>(conf.getParameter<edm::InputTag>("simTracks"));
 
   // other parameters
   maxSeedMatchEstimator = conf.getUntrackedParameter<double>("maxSeedMatchEstimator", 0);
   rejectOverlaps = conf.getParameter<bool>("OverlapCleaning");
   splitHits = conf.getParameter<bool>("SplitHits");
 }

Member Function Documentation

void TrackCandidateProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	es
	)

override

Definition at line 92 of file TrackCandidateProducer.cc.

References alongMomentum, clone(), TrackingLayer::createFromDetId(), PTrajectoryStateOnDet::detId(), TrajectorySeed::direction(), Exception, edm::OwnVector< T, P >::front(), TrackingRecHit::geographicalId(), edm::Event::getByToken(), edm::EventSetup::getData(), fastTrackingUtilities::getRecHitCombinationIndex(), fastTrackingUtilities::hitIsMasked(), fastTrackingUtilities::hitLocalError(), LowPtTripletStep_cff::hitMasks, hitMasksToken, hitSplitter, edm::EDGetTokenT< T >::isUninitialized(), TrajectoryStateOnSurface::isValid(), edm::HandleBase::isValid(), HLT_FULL_cff::magneticField, magneticFieldESToken_, SeedMatcher::matchRecHitCombinations(), maxSeedMatchEstimator, eostools::move(), TrajectorySeed::nHits(), convertSQLitetoXML_cfg::output, trajectoryStateTransform::persistentState(), HLT_FULL_cff::propagator, propagatorESToken_, edm::OwnVector< T, P >::push_back(), edm::Event::put(), DetId::rawId(), recHitCombinationsToken, TrajectorySeed::recHits(), rejectOverlaps, FastTrackerRecHit::sameId(), fileCollector::seed, DetachedQuadStep_cff::seeds, seedToken, fastTrackingUtilities::setRecHitCombinationIndex(), simTrackToken, FastTrackerRecHitSplitter::split(), splitHits, TrajectorySeed::startingState(), GeomDet::surface(), trackerGeometryESToken_, trackerTopologyESToken_, and trajectoryStateTransform::transientState().

                                                                          {
   // get records
   auto const& magneticField = es.getData(magneticFieldESToken_);
   auto const& trackerGeometry = es.getData(trackerGeometryESToken_);
   auto const& trackerTopology = es.getData(trackerTopologyESToken_);
   auto const& propagator = es.getData(propagatorESToken_);
 
   // get products
   edm::Handle<edm::View<TrajectorySeed> > seeds;
   e.getByToken(seedToken, seeds);
 
   edm::Handle<FastTrackerRecHitCombinationCollection> recHitCombinations;
   e.getByToken(recHitCombinationsToken, recHitCombinations);
 
   edm::Handle<edm::SimTrackContainer> simTracks;
   e.getByToken(simTrackToken, simTracks);
 
   edm::Handle<std::vector<bool> > hitMasks;
   if (!hitMasksToken.isUninitialized()) {
     e.getByToken(hitMasksToken, hitMasks);
   }
 
   // output collection
   std::unique_ptr<TrackCandidateCollection> output(new TrackCandidateCollection);
 
   // loop over the seeds
   for (unsigned seedIndex = 0; seedIndex < seeds->size(); ++seedIndex) {
     const TrajectorySeed seed = (*seeds)[seedIndex];
     std::vector<int32_t> recHitCombinationIndices;
 
     // match hitless seeds to simTracks and find corresponding recHitCombination
     if (seed.nHits() == 0) {
       recHitCombinationIndices = SeedMatcher::matchRecHitCombinations(
           seed, *recHitCombinations, *simTracks, maxSeedMatchEstimator, propagator, magneticField, trackerGeometry);
     }
     // for normal seeds, retrieve the corresponding recHitCombination from the seed hits
     else {
       int32_t icomb = fastTrackingUtilities::getRecHitCombinationIndex(seed);
       recHitCombinationIndices.push_back(icomb);
     }
 
     // loop over the matched recHitCombinations
     for (auto icomb : recHitCombinationIndices) {
       if (icomb < 0 || unsigned(icomb) >= recHitCombinations->size()) {
         throw cms::Exception("TrackCandidateProducer")
             << " found seed with recHitCombination out or range: " << icomb << std::endl;
       }
       const FastTrackerRecHitCombination& recHitCombination = (*recHitCombinations)[icomb];
 
       // container for select hits
       std::vector<const FastTrackerRecHit*> selectedRecHits;
 
       // add the seed hits
       for (auto const& recHit : seed.recHits()) {
         selectedRecHits.push_back(static_cast<const FastTrackerRecHit*>(&recHit));
       }
 
       // prepare to skip seed hits
       const FastTrackerRecHit* lastHitToSkip = nullptr;
       if (!selectedRecHits.empty()) {
         lastHitToSkip = selectedRecHits.back();
       }
 
       // inOut or outIn tracking ?
       bool hitsAlongMomentum = (seed.direction() == alongMomentum);
 
       // add hits from combination to hit selection
       for (unsigned hitIndex = hitsAlongMomentum ? 0 : recHitCombination.size() - 1;
            hitIndex < recHitCombination.size();
            hitsAlongMomentum ? ++hitIndex : --hitIndex) {
         const FastTrackerRecHit* selectedRecHit = recHitCombination[hitIndex].get();
 
         // skip seed hits
         if (lastHitToSkip) {
           if (lastHitToSkip->sameId(selectedRecHit)) {
             lastHitToSkip = nullptr;
           }
           continue;
         }
 
         // apply hit masking
         if (hitMasks.isValid() && fastTrackingUtilities::hitIsMasked(selectedRecHit, *hitMasks)) {
           continue;
         }
 
         //  if overlap rejection is not switched on, accept all hits
         //  always accept the first hit
         //  also accept a hit if it is not on the layer of the previous hit
         if (!rejectOverlaps || selectedRecHits.empty() ||
             (TrackingLayer::createFromDetId(selectedRecHits.back()->geographicalId(), trackerTopology) !=
              TrackingLayer::createFromDetId(selectedRecHit->geographicalId(), trackerTopology))) {
           selectedRecHits.push_back(selectedRecHit);
         }
         //  else:
         //    overlap rejection is switched on
         //    the hit is on the same layer as the previous hit
         //  accept the one with smallest error
         else if (fastTrackingUtilities::hitLocalError(selectedRecHit) <
                  fastTrackingUtilities::hitLocalError(selectedRecHits.back())) {
           selectedRecHits.back() = selectedRecHit;
         }
       }
 
       // split hits / store copies for the track candidate
       edm::OwnVector<TrackingRecHit> hitsForTrackCandidate;
       for (unsigned index = 0; index < selectedRecHits.size(); ++index) {
         if (splitHits) {
           // add split hits to splitSelectedRecHits
           hitSplitter.split(*selectedRecHits[index], hitsForTrackCandidate, hitsAlongMomentum);
         } else {
           hitsForTrackCandidate.push_back(selectedRecHits[index]->clone());
         }
       }
 
       // set the recHitCombinationIndex
       fastTrackingUtilities::setRecHitCombinationIndex(hitsForTrackCandidate, icomb);
 
       // create track candidate state
       //   1. get seed state (defined on the surface of the most outer hit)
       DetId seedDetId(seed.startingState().detId());
       const GeomDet* gdet = trackerGeometry.idToDet(seedDetId);
       TrajectoryStateOnSurface seedTSOS =
           trajectoryStateTransform::transientState(seed.startingState(), &(gdet->surface()), &magneticField);
       //   2. backPropagate the seedState to the surfuce of the most inner hit
       const GeomDet* initialLayer = trackerGeometry.idToDet(hitsForTrackCandidate.front().geographicalId());
       const TrajectoryStateOnSurface initialTSOS = propagator.propagate(seedTSOS, initialLayer->surface());
       //   3. check validity and transform
       if (!initialTSOS.isValid())
         continue;
       PTrajectoryStateOnDet PTSOD = trajectoryStateTransform::persistentState(
           initialTSOS, hitsForTrackCandidate.front().geographicalId().rawId());
 
       // add track candidate to output collection
       output->push_back(
           TrackCandidate(hitsForTrackCandidate, seed, PTSOD, edm::RefToBase<TrajectorySeed>(seeds, seedIndex)));
     }
   }
 
   // Save the track candidates
   e.put(std::move(output));
 }