Inheritance diagram for TrackCandidateProducer:

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

	TrackCandidateProducer (const edm::ParameterSet &conf)

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Private Attributes
edm::EDGetTokenT< std::vector< bool > >	hitMasksToken

FastTrackerRecHitSplitter	hitSplitter

double	maxSeedMatchEstimator

std::string	propagatorLabel

edm::EDGetTokenT< FastTrackerRecHitCombinationCollection >	recHitCombinationsToken

bool	rejectOverlaps

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

edm::EDGetTokenT< edm::SimTrackContainer >	simTrackToken

bool	splitHits

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 42 of file TrackCandidateProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 66 of file TrackCandidateProducer.cc.

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

     : 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");
     propagatorLabel = conf.getParameter<std::string>("propagator");
 }

Member Function Documentation

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

override

Definition at line 88 of file TrackCandidateProducer.cc.

References alongMomentum, clone(), TrackingLayer::createFromDetId(), DEFINE_FWK_MODULE, PTrajectoryStateOnDet::detId(), TrajectorySeed::direction(), Exception, edm::OwnVector< T, P >::front(), TrackingRecHit::geographicalId(), edm::EventSetup::get(), edm::Event::getByToken(), fastTrackingUtilities::getRecHitCombinationIndex(), fastTrackingUtilities::hitIsMasked(), fastTrackingUtilities::hitLocalError(), DetachedQuadStep_cff::hitMasks, hitMasksToken, hitSplitter, TrackerGeometry::idToDet(), edm::EDGetTokenT< T >::isUninitialized(), TrajectoryStateOnSurface::isValid(), edm::HandleBase::isValid(), seedCreatorFromRegionConsecutiveHitsEDProducer_cff::magneticField, SeedMatcher::matchRecHitCombinations(), maxSeedMatchEstimator, eostools::move(), TrajectorySeed::nHits(), convertSQLitetoXML_cfg::output, trajectoryStateTransform::persistentState(), edm::ESHandle< T >::product(), Propagator::propagate(), PhotonConversionTrajectorySeedProducerFromQuadruplets_cfi::propagator, propagatorLabel, edm::OwnVector< T, P >::push_back(), edm::Event::put(), DetId::rawId(), recHitCombinationsToken, TrajectorySeed::recHits(), rejectOverlaps, FastTrackerRecHit::sameId(), SurveyInfoScenario_cff::seed, seedToken, fastTrackingUtilities::setRecHitCombinationIndex(), tkConvValidator_cfi::simTracks, simTrackToken, FastTrackerRecHitSplitter::split(), splitHits, TrajectorySeed::startingState(), TrajectoryStateOnSurface::surface(), and trajectoryStateTransform::transientState().

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                     {        
 
     // get records
     edm::ESHandle<MagneticField>          magneticField;
     es.get<IdealMagneticFieldRecord>().get(magneticField);
 
     edm::ESHandle<TrackerGeometry>        trackerGeometry;
     es.get<TrackerDigiGeometryRecord>().get(trackerGeometry);
 
     edm::ESHandle<TrackerTopology>        trackerTopology;
     es.get<TrackerTopologyRcd>().get(trackerTopology);
 
     edm::ESHandle<Propagator>             propagator;
     es.get<TrackingComponentsRecord>().get(propagatorLabel,propagator);
 
     // 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
         TrajectorySeed::range seedHitRange = seed.recHits();//Hits in a seed
         for (TrajectorySeed::const_iterator ihit = seedHitRange.first; ihit != seedHitRange.second; ++ihit)
         {
         selectedRecHits.push_back(static_cast<const FastTrackerRecHit*>(&*ihit));
         }
 
         // 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.product())
              != TrackingLayer::createFromDetId(selectedRecHit->geographicalId(),*trackerTopology.product())))
         {
             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.product());
         //   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));
     
 }