#include <SeedFinderSelector.h>

Public Member Functions
void	initEvent (const edm::Event &ev, const edm::EventSetup &es)

bool	pass (const std::vector< const FastTrackerRecHit * > &hits) const

	SeedFinderSelector (const edm::ParameterSet &cfg, edm::ConsumesCollector &&consumesCollector)

void	setTrackingRegion (const TrackingRegion *trackingRegion)

	~SeedFinderSelector ()

Private Attributes
const edm::EventSetup *	eventSetup_

const MeasurementTracker *	measurementTracker_

const std::string	measurementTrackerLabel_

std::unique_ptr< MultiHitGeneratorFromPairAndLayers >	multiHitGenerator_

std::unique_ptr< HitTripletGeneratorFromPairAndLayers >	pixelTripletGenerator_

const TrackingRegion *	trackingRegion_

Detailed Description

Definition at line 22 of file SeedFinderSelector.h.

Constructor & Destructor Documentation

SeedFinderSelector::SeedFinderSelector	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	consumesCollector
	)

Definition at line 21 of file SeedFinderSelector.cc.

References beamerCreator::create(), Exception, edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), multiHitGenerator_, pixelTripletGenerator_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : trackingRegion_(0)
     , eventSetup_(0)
     , measurementTracker_(0)
     , measurementTrackerLabel_(cfg.getParameter<std::string>("measurementTracker"))
 {
     if(cfg.exists("pixelTripletGeneratorFactory"))
     {
         const edm::ParameterSet & tripletConfig = cfg.getParameter<edm::ParameterSet>("pixelTripletGeneratorFactory");
         pixelTripletGenerator_.reset(HitTripletGeneratorFromPairAndLayersFactory::get()->create(tripletConfig.getParameter<std::string>("ComponentName"),tripletConfig,consumesCollector));
     }
 
     if(cfg.exists("MultiHitGeneratorFactory"))
     {
         const edm::ParameterSet & tripletConfig = cfg.getParameter<edm::ParameterSet>("MultiHitGeneratorFactory");
         multiHitGenerator_.reset(MultiHitGeneratorFromPairAndLayersFactory::get()->create(tripletConfig.getParameter<std::string>("ComponentName"),tripletConfig));
     }
 
     if(pixelTripletGenerator_ && multiHitGenerator_)
     {
     throw cms::Exception("FastSimTracking") << "It is forbidden to specify both 'pixelTripletGeneratorFactory' and 'MultiHitGeneratorFactory' in configuration of SeedFinderSelection";
     }
 }

SeedFinderSelector::~SeedFinderSelector ( )

Definition at line 46 of file SeedFinderSelector.cc.

46 {;}

Member Function Documentation

void SeedFinderSelector::initEvent	(	const edm::Event &	ev,
		const edm::EventSetup &	es
	)

Definition at line 48 of file SeedFinderSelector.cc.

References eventSetup_, edm::EventSetup::get(), measurementTracker_, measurementTrackerLabel_, and multiHitGenerator_.

 {
     eventSetup_ = &es;
     
     edm::ESHandle<MeasurementTracker> measurementTrackerHandle;
     es.get<CkfComponentsRecord>().get(measurementTrackerLabel_, measurementTrackerHandle);
     measurementTracker_ = &(*measurementTrackerHandle);
 
     if(multiHitGenerator_)
     {
         multiHitGenerator_->initES(es);
     }
 }

bool SeedFinderSelector::pass ( const std::vector< const FastTrackerRecHit * > & hits ) const

Definition at line 63 of file SeedFinderSelector.cc.

References GeometricSearchTracker::detLayer(), HitPairGeneratorFromLayerPair::doublets(), eventSetup_, Exception, MeasurementTracker::geometricSearchTracker(), measurementTracker_, multiHitGenerator_, TrackingRegion::origin(), pixelTripletGenerator_, mps_fire::result, OrderedMultiHits::size(), OrderedHitTriplets::size(), and trackingRegion_.

 {
     if(!measurementTracker_ || !eventSetup_)
     {
     throw cms::Exception("FastSimTracking") << "ERROR: event not initialized";
     }
     if(!trackingRegion_)
     {
     throw cms::Exception("FastSimTracking") << "ERROR: trackingRegion not set";
     }
 
 
     // check the inner 2 hits
     if(hits.size() < 2)
     {
     throw cms::Exception("FastSimTracking") << "SeedFinderSelector::pass requires at least 2 hits";
     }
     const DetLayer * firstLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[0]->det()->geographicalId());
     const DetLayer * secondLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[1]->det()->geographicalId());
     
     std::vector<BaseTrackerRecHit const *> firstHits(1,static_cast<const BaseTrackerRecHit*>(hits[0]));
     std::vector<BaseTrackerRecHit const *> secondHits(1,static_cast<const BaseTrackerRecHit*>(hits[1]));
     
     const RecHitsSortedInPhi fhm(firstHits, trackingRegion_->origin(), firstLayer);
     const RecHitsSortedInPhi shm(secondHits, trackingRegion_->origin(), secondLayer);
     
     HitDoublets result(fhm,shm);
     HitPairGeneratorFromLayerPair::doublets(*trackingRegion_,*firstLayer,*secondLayer,fhm,shm,*eventSetup_,0,result);
     
     if(result.size()==0)
     {
     return false;
     }
     
     // check the inner 3 hits
     if(pixelTripletGenerator_ || multiHitGenerator_)
     {
     if(hits.size() < 3)
     {
         throw cms::Exception("FastSimTracking") << "For the given configuration, SeedFinderSelector::pass requires at least 3 hits";
     }
     const DetLayer * thirdLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[2]->det()->geographicalId());
     std::vector<const DetLayer *> thirdLayerDetLayer(1,thirdLayer);
     std::vector<BaseTrackerRecHit const *> thirdHits(1,static_cast<const BaseTrackerRecHit*>(hits[2]));
     const RecHitsSortedInPhi thm(thirdHits,trackingRegion_->origin(), thirdLayer);
     const RecHitsSortedInPhi * thmp =&thm;
     
     if(pixelTripletGenerator_)
     {
         OrderedHitTriplets tripletresult;
         pixelTripletGenerator_->hitTriplets(*trackingRegion_,tripletresult,*eventSetup_,result,&thmp,thirdLayerDetLayer,1);
         return tripletresult.size()!=0;
     }
     else if(multiHitGenerator_)
     {
         OrderedMultiHits  tripletresult;
         multiHitGenerator_->hitTriplets(*trackingRegion_,tripletresult,*eventSetup_,result,&thmp,thirdLayerDetLayer,1);
         return tripletresult.size()!=0;
     }
 
     }
     return true;
     
 }