#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

	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< 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<>
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 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));
 }