#include <PixelTrackReconstruction.h>

Public Member Functions
	PixelTrackReconstruction (const edm::ParameterSet &conf, edm::ConsumesCollector &&iC)

void	run (pixeltrackfitting::TracksWithTTRHs &tah, edm::Event &ev, const edm::EventSetup &es)

	~PixelTrackReconstruction ()

Static Public Member Functions
static void	fillDescriptions (edm::ParameterSetDescription &desc)

Private Attributes
edm::ESGetToken < PixelTrackCleaner, PixelTrackCleaner::Record >	theCleanerToken

edm::EDGetTokenT < PixelTrackFilter >	theFilterToken

edm::EDGetTokenT< PixelFitter >	theFitterToken

edm::EDGetTokenT < RegionsSeedingHitSets >	theHitSetsToken

Detailed Description

Definition at line 18 of file PixelTrackReconstruction.h.

Constructor & Destructor Documentation

PixelTrackReconstruction::PixelTrackReconstruction	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &&	iC
	)

Definition at line 21 of file PixelTrackReconstruction.cc.

References edm::ParameterSet::getParameter(), edm::InputTag::label(), AlCaHLTBitMon_QueryRunRegistry::string, theCleanerToken, and theFilterToken.

     : theHitSetsToken(iC.consumes<RegionsSeedingHitSets>(cfg.getParameter<edm::InputTag>("SeedingHitSets"))),
       theFitterToken(iC.consumes<PixelFitter>(cfg.getParameter<edm::InputTag>("Fitter"))) {
   edm::InputTag filterTag = cfg.getParameter<edm::InputTag>("Filter");
   if (not filterTag.label().empty()) {
     theFilterToken = iC.consumes<PixelTrackFilter>(filterTag);
   }
   std::string cleanerName = cfg.getParameter<std::string>("Cleaner");
   if (not cleanerName.empty()) {
     theCleanerToken = iC.esConsumes(edm::ESInputTag("", cleanerName));
   }
 }

PixelTrackReconstruction::~PixelTrackReconstruction ( )

Definition at line 34 of file PixelTrackReconstruction.cc.

34 {}

Member Function Documentation

void PixelTrackReconstruction::fillDescriptions ( edm::ParameterSetDescription & desc )

static

Definition at line 36 of file PixelTrackReconstruction.cc.

References edm::ParameterSetDescription::add(), HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PixelTrackProducer::fillDescriptions().

                                                                                 {
   desc.add<edm::InputTag>("SeedingHitSets", edm::InputTag("pixelTracksHitTriplets"));
   desc.add<edm::InputTag>("Fitter", edm::InputTag("pixelFitterByHelixProjections"));
   desc.add<edm::InputTag>("Filter", edm::InputTag("pixelTrackFilterByKinematics"));
   desc.add<std::string>("Cleaner", "pixelTrackCleanerBySharedHits");
 }

void PixelTrackReconstruction::run	(	pixeltrackfitting::TracksWithTTRHs &	tah,
		edm::Event &	ev,
		const edm::EventSetup &	es
	)

FIXME at some point we need to migrate the fitter...

Definition at line 43 of file PixelTrackReconstruction.cc.

References PixelTrackCleanerWrapper::clean(), alcazmumu_cfi::filter, edm::Event::getByToken(), edm::EventSetup::getData(), edm::ESGetToken< T, R >::isInitialized(), edm::EDGetTokenT< T >::isUninitialized(), nHits, edm::Handle< T >::product(), HLT_FULL_cff::region, theCleanerToken, theFilterToken, theFitterToken, theHitSetsToken, and HLT_FULL_cff::track.

                                                                                                  {
   edm::Handle<RegionsSeedingHitSets> hhitSets;
   ev.getByToken(theHitSetsToken, hhitSets);
   const auto& hitSets = *hhitSets;
 
   edm::Handle<PixelFitter> hfitter;
   ev.getByToken(theFitterToken, hfitter);
   const auto& fitter = *hfitter;
 
   const PixelTrackFilter* filter = nullptr;
   if (!theFilterToken.isUninitialized()) {
     edm::Handle<PixelTrackFilter> hfilter;
     ev.getByToken(theFilterToken, hfilter);
     filter = hfilter.product();
   }
 
   std::vector<const TrackingRecHit*> hits;
   hits.reserve(4);
   for (const auto& regionHitSets : hitSets) {
     const TrackingRegion& region = regionHitSets.region();
 
     for (const SeedingHitSet& tuplet : regionHitSets) {
       auto nHits = tuplet.size();
       hits.resize(nHits);
       for (unsigned int iHit = 0; iHit < nHits; ++iHit)
         hits[iHit] = tuplet[iHit];
 
       // fitting
       std::unique_ptr<reco::Track> track = fitter.run(hits, region);
       if (!track)
         continue;
 
       if (filter) {
         if (!(*filter)(track.get(), hits)) {
           continue;
         }
       }
       /* roll back to verify if HLT tau is affected  
       // all legacy tracks are "highPurity"
       // setting all others bits as well (as in ckf)
       track->setQuality(reco::TrackBase::loose);
       track->setQuality(reco::TrackBase::tight);
       track->setQuality(reco::TrackBase::highPurity);
       */
       // add tracks
       tracks.emplace_back(track.release(), tuplet);
     }
   }
 
   // skip ovelrapped tracks
   if (theCleanerToken.isInitialized()) {
     const auto& cleaner = es.getData(theCleanerToken);
     if (cleaner.fast())
       cleaner.cleanTracks(tracks);
     else
       tracks = PixelTrackCleanerWrapper(&cleaner).clean(tracks);
   }
 }