#include <PixelTrackReconstruction.h>

Public Member Functions
void	halt ()

void	init (const edm::EventSetup &es)

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

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

	~PixelTrackReconstruction ()

Private Attributes
PixelTrackCleaner *	theCleaner

edm::ParameterSet	theConfig

std::unique_ptr< PixelTrackFilter >	theFilter

const PixelFitter *	theFitter

std::unique_ptr < OrderedHitsGenerator >	theGenerator

std::unique_ptr < QuadrupletSeedMerger >	theMerger_

std::unique_ptr < TrackingRegionProducer >	theRegionProducer

bool	useClusterShape

Detailed Description

Definition at line 19 of file PixelTrackReconstruction.h.

Constructor & Destructor Documentation

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

Definition at line 37 of file PixelTrackReconstruction.cc.

References beamerCreator::create(), edm::ParameterSet::exists(), reco_skim_cfg_mod::filterName, reco::get(), edm::ParameterSet::getParameter(), eostools::move(), AlCaHLTBitMon_QueryRunRegistry::string, theConfig, theFilter, theGenerator, theMerger_, theRegionProducer, and useClusterShape.

   : theConfig(cfg), theFitter(0), theCleaner(0)
 {
   if ( cfg.exists("SeedMergerPSet") ) {
     edm::ParameterSet mergerPSet = theConfig.getParameter<edm::ParameterSet>( "SeedMergerPSet" );
     std::string seedmergerTTRHBuilderLabel = mergerPSet.getParameter<std::string>( "ttrhBuilderLabel" );
     edm::ParameterSet seedmergerLayerList = mergerPSet.getParameter<edm::ParameterSet>( "layerList" );
     bool seedmergerAddTriplets = mergerPSet.getParameter<bool>( "addRemainingTriplets" );
     bool seedmergerMergeTriplets = mergerPSet.getParameter<bool>( "mergeTriplets" );
     theMerger_.reset(new QuadrupletSeedMerger(seedmergerLayerList, iC));
     theMerger_->setMergeTriplets( seedmergerMergeTriplets );
     theMerger_->setAddRemainingTriplets( seedmergerAddTriplets );
     theMerger_->setTTRHBuilderLabel( seedmergerTTRHBuilderLabel );
   }
 
   ParameterSet filterPSet = theConfig.getParameter<ParameterSet>("FilterPSet");
   std::string  filterName = filterPSet.getParameter<std::string>("ComponentName");
   if (filterName != "none") {
     theFilter.reset(PixelTrackFilterFactory::get()->create( filterName, filterPSet, iC));
     if(theConfig.exists("useFilterWithES")) {
       edm::LogInfo("Obsolete") << "useFilterWithES parameter is obsolete and can be removed";
     }
     useClusterShape = filterPSet.exists("useClusterShape");
   }
 
   ParameterSet orderedPSet =
       theConfig.getParameter<ParameterSet>("OrderedHitsFactoryPSet");
   std::string orderedName = orderedPSet.getParameter<std::string>("ComponentName");
   theGenerator.reset(OrderedHitsGeneratorFactory::get()->create( orderedName, orderedPSet, iC));
 
   ParameterSet regfactoryPSet = theConfig.getParameter<ParameterSet>("RegionFactoryPSet");
   std::string regfactoryName = regfactoryPSet.getParameter<std::string>("ComponentName");
   theRegionProducer.reset(TrackingRegionProducerFactory::get()->create(regfactoryName,regfactoryPSet, std::move(iC)));
 }

PixelTrackReconstruction::~PixelTrackReconstruction ( )

Definition at line 73 of file PixelTrackReconstruction.cc.

References halt().

 {
   halt();
 }

Member Function Documentation

void PixelTrackReconstruction::halt ( )

Definition at line 78 of file PixelTrackReconstruction.cc.

References theCleaner, and theFitter.

Referenced by PixelTrackProducer::endRun(), and ~PixelTrackReconstruction().

 {
   delete theFitter; theFitter=0;
   delete theCleaner; theCleaner=0;
 }

void PixelTrackReconstruction::init ( const edm::EventSetup & es )

Definition at line 84 of file PixelTrackReconstruction.cc.

References reco::get(), edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, theCleaner, theConfig, theFitter, and theMerger_.

Referenced by PixelTrackProducer::beginRun().

 {
 
   ParameterSet fitterPSet = theConfig.getParameter<ParameterSet>("FitterPSet");
   std::string fitterName = fitterPSet.getParameter<std::string>("ComponentName");
   theFitter = PixelFitterFactory::get()->create( fitterName, fitterPSet);
 
   ParameterSet cleanerPSet = theConfig.getParameter<ParameterSet>("CleanerPSet");
   std::string  cleanerName = cleanerPSet.getParameter<std::string>("ComponentName");
   if (cleanerName != "none") theCleaner = PixelTrackCleanerFactory::get()->create( cleanerName, cleanerPSet);
 
   if (theMerger_) {
     theMerger_->update( es );
   }
 }

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 100 of file PixelTrackReconstruction.cc.

References PixelTrackCleanerWrapper::clean(), PixelTrackCleaner::cleanTracks(), PixelTrackCleaner::fast, edm::EventSetup::get(), edm::ESHandle< class >::product(), HLT_25ns10e33_v2_cff::region, HLT_25ns10e33_v2_cff::Regions, PixelFitter::run(), OrderedSeedingHits::size(), SeedingHitSet::size(), theCleaner, theFilter, theFitter, theGenerator, theMerger_, theRegionProducer, and useClusterShape.

Referenced by PixelTrackProducer::produce().

 {
   typedef std::vector<std::unique_ptr<TrackingRegion> > Regions;
   typedef Regions::const_iterator IR;
   Regions regions = theRegionProducer->regions(ev,es);
 
   //Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHand;
   es.get<TrackerTopologyRcd>().get(tTopoHand);
   const TrackerTopology *tTopo=tTopoHand.product();
 
   if (theFilter) theFilter->update(ev, es);
   
   std::vector<const TrackingRecHit *> hits;hits.reserve(4); 
   for (IR ir=regions.begin(), irEnd=regions.end(); ir < irEnd; ++ir) {
     const TrackingRegion & region = **ir;
 
     const OrderedSeedingHits & triplets =  theGenerator->run(region,ev,es);
     const OrderedSeedingHits &tuplets= (theMerger_==0)? triplets : theMerger_->mergeTriplets( triplets, es );
 
     unsigned int nTuplets = tuplets.size();
     tracks.reserve(tracks.size()+nTuplets);
     // producing tracks
     for (unsigned int iTuplet = 0; iTuplet < nTuplets; ++iTuplet) {
       const SeedingHitSet & tuplet = tuplets[iTuplet];
 
       auto nHits = tuplet.size(); hits.resize(nHits);
       for (unsigned int iHit = 0; iHit < nHits; ++iHit) hits[iHit] = tuplet[iHit];
    
       // fitting
       reco::Track* track = theFitter->run( ev, es, hits, region);
       if (!track) continue;
 
       if (theFilter) {
     if ((useClusterShape && !(*theFilter)(track, hits, tTopo)) ||
         (!useClusterShape && !(*theFilter)(track, hits))) {
       delete track;
       continue;
     }
       }
 
       // add tracks
       tracks.emplace_back(track, tuplet);
     }
     theGenerator->clear();
   }
 
   // skip ovelrapped tracks
   
   if (theCleaner) {
     if (theCleaner->fast)
        theCleaner->cleanTracks(tracks,tTopo);
     else
       tracks = PixelTrackCleanerWrapper(theCleaner).clean(tracks,tTopo);
   }
 }