#include <PixelTracksProducer.h>

Inheritance diagram for PixelTracksProducer:

Public Member Functions
	PixelTracksProducer (const edm::ParameterSet &conf)

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

	~PixelTracksProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
edm::EDGetTokenT< PixelTrackFilter >	filterToken

edm::EDGetTokenT< PixelFitter >	fitterToken

edm::EDGetTokenT< TrajectorySeedCollection >	seedProducerToken

std::unique_ptr< TrackingRegionProducer >	theRegionProducer

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 21 of file PixelTracksProducer.h.

Constructor & Destructor Documentation

◆ PixelTracksProducer()

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

explicit

Definition at line 35 of file PixelTracksProducer.cc.

                                                                     : theRegionProducer(nullptr) {
   produces<reco::TrackCollection>();
   produces<TrackingRecHitCollection>();
   produces<reco::TrackExtraCollection>();
  
   const edm::ParameterSet& regfactoryPSet = conf.getParameter<edm::ParameterSet>("RegionFactoryPSet");
   std::string regfactoryName = regfactoryPSet.getParameter<std::string>("ComponentName");
   theRegionProducer = TrackingRegionProducerFactory::get()->create(regfactoryName, regfactoryPSet, consumesCollector());
  
   fitterToken = consumes<PixelFitter>(conf.getParameter<edm::InputTag>("Fitter"));
   filterToken = consumes<PixelTrackFilter>(conf.getParameter<edm::InputTag>("Filter"));
  
   // The name of the seed producer
   auto seedProducer = conf.getParameter<edm::InputTag>("SeedProducer");
   seedProducerToken = consumes<TrajectorySeedCollection>(seedProducer);
 }

References filterToken, fitterToken, get, edm::ParameterSet::getParameter(), seedProducerToken, AlCaHLTBitMon_QueryRunRegistry::string, and theRegionProducer.

◆ ~PixelTracksProducer()

PixelTracksProducer::~PixelTracksProducer ( )

overridedefault

Member Function Documentation

◆ produce()

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

override

Definition at line 56 of file PixelTracksProducer.cc.

                                                                       {
   std::unique_ptr<reco::TrackCollection> tracks(new reco::TrackCollection);
   std::unique_ptr<TrackingRecHitCollection> recHits(new TrackingRecHitCollection);
   std::unique_ptr<reco::TrackExtraCollection> trackExtras(new reco::TrackExtraCollection);
   typedef std::vector<const TrackingRecHit*> RecHits;
  
   TracksWithRecHits pixeltracks;
   TracksWithRecHits cleanedTracks;
  
   edm::ESHandle<TrackerTopology> httopo;
   es.get<TrackerTopologyRcd>().get(httopo);
   const TrackerTopology& ttopo = *httopo;
  
   edm::Handle<PixelFitter> hfitter;
   e.getByToken(fitterToken, hfitter);
   const PixelFitter& fitter = *hfitter;
  
   edm::Handle<PixelTrackFilter> hfilter;
   e.getByToken(filterToken, hfilter);
   const PixelTrackFilter& theFilter = *hfilter;
  
   edm::Handle<TrajectorySeedCollection> theSeeds;
   e.getByToken(seedProducerToken, theSeeds);
  
   // No seed -> output an empty track collection
   if (theSeeds->empty()) {
     e.put(std::move(tracks));
     e.put(std::move(recHits));
     e.put(std::move(trackExtras));
     return;
   }
  
   //only one region Global, but it is called at every event...
   //maybe there is a smarter way to set it only once
   //NEED TO FIX
   typedef std::vector<std::unique_ptr<TrackingRegion> > Regions;
   typedef Regions::const_iterator IR;
   Regions regions = theRegionProducer->regions(e, es);
   for (IR ir = regions.begin(), irEnd = regions.end(); ir < irEnd; ++ir) {
     const TrackingRegion& region = **ir;
  
     // Loop over the seeds
     TrajectorySeedCollection::const_iterator aSeed = theSeeds->begin();
     TrajectorySeedCollection::const_iterator lastSeed = theSeeds->end();
     for (; aSeed != lastSeed; ++aSeed) {
       // Loop over the rechits
       std::vector<const TrackingRecHit*> TripletHits(3, static_cast<const TrackingRecHit*>(nullptr));
       unsigned int iRecHit = 0;
       for (auto const& recHit : aSeed->recHits()) {
         TripletHits[iRecHit] = &recHit;
         ++iRecHit;
       }
  
       // fitting the triplet
       std::unique_ptr<reco::Track> track = fitter.run(TripletHits, region, es);
  
       // decide if track should be skipped according to filter
       if (!theFilter(track.get(), TripletHits)) {
         continue;
       }
  
       // add tracks
       pixeltracks.push_back(TrackWithRecHits(track.release(), TripletHits));
     }
   }
  
   int cc = 0;
   int nTracks = pixeltracks.size();
   for (int i = 0; i < nTracks; ++i) {
     reco::Track* track = pixeltracks.at(i).first;
     const RecHits& hits = pixeltracks.at(i).second;
  
     for (unsigned int k = 0; k < hits.size(); k++) {
       TrackingRecHit* hit = (hits.at(k))->clone();
       track->appendHitPattern(*hit, ttopo);
       recHits->push_back(hit);
     }
  
     tracks->push_back(*track);
     delete track;
   }
  
   edm::OrphanHandle<TrackingRecHitCollection> ohRH = e.put(std::move(recHits));
   edm::RefProd<TrackingRecHitCollection> ohRHProd(ohRH);
  
   for (int k = 0; k < nTracks; ++k) {
     // reco::TrackExtra* theTrackExtra = new reco::TrackExtra();
     reco::TrackExtra theTrackExtra;
  
     //fill the TrackExtra with TrackingRecHitRef
     // unsigned int nHits = tracks->at(k).numberOfValidHits();
     const unsigned nHits = 3;  // We are dealing with triplets!
     theTrackExtra.setHits(ohRHProd, cc, nHits);
     cc += nHits;
  
     trackExtras->push_back(theTrackExtra);
     //trackExtras->push_back(*theTrackExtra);
     //delete theTrackExtra;
   }
  
   edm::OrphanHandle<reco::TrackExtraCollection> ohTE = e.put(std::move(trackExtras));
  
   for (int k = 0; k < nTracks; k++) {
     const reco::TrackExtraRef theTrackExtraRef(ohTE, k);
     (tracks->at(k)).setExtra(theTrackExtraRef);
   }
  
   e.put(std::move(tracks));
 }