#include <SeedFinderSelector.h>

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

SeedingLayerSetsBuilder::SeedingLayerId	Layer_tuple (const FastTrackerRecHit *hit) const

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
std::unique_ptr< CAHitQuadrupletGenerator >	CAHitQuadGenerator_

std::unique_ptr< CAHitTripletGenerator >	CAHitTriplGenerator_

const edm::EventSetup *	eventSetup_

std::vector< unsigned >	layerPairs_

const MeasurementTracker *	measurementTracker_

const std::string	measurementTrackerLabel_

std::unique_ptr< MultiHitGeneratorFromPairAndLayers >	multiHitGenerator_

std::unique_ptr< HitTripletGeneratorFromPairAndLayers >	pixelTripletGenerator_

std::unique_ptr< SeedingLayerSetsHits >	seedingLayer

std::vector< SeedingLayerSetsBuilder::SeedingLayerId >	seedingLayerIds

std::unique_ptr< SeedingLayerSetsBuilder >	seedingLayers_

edm::ESHandle< TrackerTopology >	trackerTopology

const TrackingRegion *	trackingRegion_

Detailed Description

Definition at line 29 of file SeedFinderSelector.h.

Constructor & Destructor Documentation

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

Definition at line 24 of file SeedFinderSelector.cc.

References CAHitQuadGenerator_, CAHitTriplGenerator_, looper::cfg, Exception, edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), layerPairs_, multiHitGenerator_, pixelTripletGenerator_, seedingLayers_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : trackingRegion_(nullptr)
     , eventSetup_(nullptr)
     , measurementTracker_(nullptr)
     , measurementTrackerLabel_(cfg.getParameter<std::string>("measurementTracker"))
 {
     if(cfg.exists("pixelTripletGeneratorFactory"))
     {
         const edm::ParameterSet & tripletConfig = cfg.getParameter<edm::ParameterSet>("pixelTripletGeneratorFactory");
         pixelTripletGenerator_ = std::unique_ptr<HitTripletGeneratorFromPairAndLayers>{HitTripletGeneratorFromPairAndLayersFactory::get()->create(tripletConfig.getParameter<std::string>("ComponentName"),tripletConfig,consumesCollector)};
     }
 
     if(cfg.exists("MultiHitGeneratorFactory"))
     {
         const edm::ParameterSet & tripletConfig = cfg.getParameter<edm::ParameterSet>("MultiHitGeneratorFactory");
         multiHitGenerator_ = std::unique_ptr<MultiHitGeneratorFromPairAndLayers>{MultiHitGeneratorFromPairAndLayersFactory::get()->create(tripletConfig.getParameter<std::string>("ComponentName"),tripletConfig)};
     }
 
     if(cfg.exists("CAHitTripletGeneratorFactory"))
     {
         const edm::ParameterSet & tripletConfig = cfg.getParameter<edm::ParameterSet>("CAHitTripletGeneratorFactory");
     CAHitTriplGenerator_ = std::make_unique<CAHitTripletGenerator>(tripletConfig,consumesCollector);
     seedingLayers_ = std::make_unique<SeedingLayerSetsBuilder>(cfg, consumesCollector, edm::InputTag("fastTrackerRecHits")); //calling the new FastSim specific constructor to make SeedingLayerSetsHits pointer for triplet iterations
         layerPairs_ = cfg.getParameter<std::vector<unsigned>>("layerPairs"); //allowed layer pairs for CA triplets
     }
 
     if(cfg.exists("CAHitQuadrupletGeneratorFactory"))
     {
         const edm::ParameterSet & quadrupletConfig = cfg.getParameter<edm::ParameterSet>("CAHitQuadrupletGeneratorFactory");
     CAHitQuadGenerator_ = std::make_unique<CAHitQuadrupletGenerator>(quadrupletConfig, consumesCollector);
     seedingLayers_ = std::make_unique<SeedingLayerSetsBuilder>(cfg, consumesCollector, edm::InputTag("fastTrackerRecHits")); //calling the new FastSim specific constructor to make SeedingLayerSetsHits pointer for quadruplet iterations
     layerPairs_ = cfg.getParameter<std::vector<unsigned>>("layerPairs"); //allowed layer pairs for CA quadruplets
     }
 
     if((pixelTripletGenerator_ && multiHitGenerator_) || (CAHitTriplGenerator_ && pixelTripletGenerator_) || (CAHitTriplGenerator_ && multiHitGenerator_))
       {
     throw cms::Exception("FastSimTracking") << "It is forbidden to specify together 'pixelTripletGeneratorFactory', 'CAHitTripletGeneratorFactory' and 'MultiHitGeneratorFactory' in configuration of SeedFinderSelection";
       }
     if((pixelTripletGenerator_ && CAHitQuadGenerator_) || (CAHitTriplGenerator_ && CAHitQuadGenerator_) || (multiHitGenerator_ && CAHitQuadGenerator_))
       {
     throw cms::Exception("FastSimTracking") << "It is forbidden to specify 'CAHitQuadrupletGeneratorFactory' together with 'pixelTripletGeneratorFactory', 'CAHitTripletGeneratorFactory' or 'MultiHitGeneratorFactory' in configuration of SeedFinderSelection";
       }  
 }

SeedFinderSelector::~SeedFinderSelector ( )

Definition at line 69 of file SeedFinderSelector.cc.

69 {;}

Member Function Documentation

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

Definition at line 71 of file SeedFinderSelector.cc.

References CAHitQuadGenerator_, CAHitTriplGenerator_, eventSetup_, edm::EventSetup::get(), measurementTracker_, measurementTrackerLabel_, multiHitGenerator_, seedingLayer, seedingLayerIds, seedingLayers_, and trackerTopology.

 {
     eventSetup_ = &es;
      
     edm::ESHandle<MeasurementTracker> measurementTrackerHandle;
     es.get<CkfComponentsRecord>().get(measurementTrackerLabel_, measurementTrackerHandle);
     es.get<TrackerTopologyRcd>().get(trackerTopology);
     measurementTracker_ = &(*measurementTrackerHandle);
 
     if(multiHitGenerator_)
     {
         multiHitGenerator_->initES(es);
     }
 
     //for CA triplet iterations
     if(CAHitTriplGenerator_){
       seedingLayer = seedingLayers_->makeSeedingLayerSetsHitsforFastSim(ev, es);
       seedingLayerIds = seedingLayers_->layers();
       CAHitTriplGenerator_->initEvent(ev,es);
     }
     //for CA quadruplet iterations
     if(CAHitQuadGenerator_){
       seedingLayer = seedingLayers_->makeSeedingLayerSetsHitsforFastSim(ev, es);
       seedingLayerIds = seedingLayers_->layers();
       CAHitQuadGenerator_->initEvent(ev,es);
     }    
 }

SeedingLayerSetsBuilder::SeedingLayerId SeedFinderSelector::Layer_tuple ( const FastTrackerRecHit * hit ) const

Definition at line 304 of file SeedFinderSelector.cc.

References Barrel, TrackingRecHit::det(), GeomDet::geographicalId(), GeomDetEnumerators::invalidDet, NegEndcap, GeomDetEnumerators::PixelBarrel, PixelSubdetector::PixelBarrel, GeomDetEnumerators::PixelEndcap, PixelSubdetector::PixelEndcap, PosEndcap, edm::ESHandle< T >::product(), TrackerTopology::pxbLayer(), TrackerTopology::pxfDisk(), TrackerTopology::pxfSide(), and trackerTopology.

Referenced by pass().

 {
   const TrackerTopology* const tTopo = trackerTopology.product();
   GeomDetEnumerators::SubDetector subdet = GeomDetEnumerators::invalidDet;
   TrackerDetSide side = TrackerDetSide::Barrel;
   int idLayer = 0;
   
   if( (hit->det()->geographicalId()).subdetId() == PixelSubdetector::PixelBarrel){
     subdet = GeomDetEnumerators::PixelBarrel;
     side = TrackerDetSide::Barrel;
     idLayer = tTopo->pxbLayer(hit->det()->geographicalId());
   }
   else if ((hit->det()->geographicalId()).subdetId() == PixelSubdetector::PixelEndcap){
     subdet = GeomDetEnumerators::PixelEndcap;
     idLayer = tTopo->pxfDisk(hit->det()->geographicalId());
     if(tTopo->pxfSide(hit->det()->geographicalId())==1){
       side = TrackerDetSide::NegEndcap;
     }
     else{
       side = TrackerDetSide::PosEndcap;
     }
   }
   return std::make_tuple(subdet, side, idLayer);
 }

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

Definition at line 100 of file SeedFinderSelector.cc.

References IntermediateHitDoublets::beginRegion(), CAHitQuadGenerator_, CAHitTriplGenerator_, GeometricSearchTracker::detLayer(), HitPairGeneratorFromLayerPair::doublets(), eventSetup_, Exception, objects.autophobj::filler, MeasurementTracker::geometricSearchTracker(), Layer_tuple(), layerPairs_, LayerTriplets::layers(), eostools::ls(), measurementTracker_, eostools::move(), multiHitGenerator_, TrackingRegion::origin(), AlCaHLTBitMon_ParallelJobs::p, pixelTripletGenerator_, IntermediateHitDoublets::regionSize(), mps_fire::result, seedingLayer, seedingLayerIds, 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{hits[0]};
     std::vector<BaseTrackerRecHit const *> secondHits{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.empty())
     {
     return false;
     }
     
     // check the inner 3 hits
     if(pixelTripletGenerator_ || multiHitGenerator_ || CAHitTriplGenerator_)
     {
     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{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.empty();
     }
     else if(multiHitGenerator_)
     {
         OrderedMultiHits  tripletresult;
         multiHitGenerator_->hitTriplets(*trackingRegion_,tripletresult,*eventSetup_,result,&thmp,thirdLayerDetLayer,1);
         return !tripletresult.empty();
     }
     //new for Phase1
     else if(CAHitTriplGenerator_)
     {  
       if(!seedingLayer)
         throw cms::Exception("FastSimTracking") << "ERROR: SeedingLayers pointer not set for CATripletGenerator";
 
       SeedingLayerSetsHits & layers = *seedingLayer;
       //constructing IntermediateHitDoublets to be passed onto CAHitTripletGenerator::hitNtuplets()
       IntermediateHitDoublets ihd(&layers);
       const TrackingRegion& tr_ = *trackingRegion_;
       auto filler = ihd.beginRegion(&tr_); 
 
       //forming the SeedingLayerId of the hits
       std::array<SeedingLayerSetsBuilder::SeedingLayerId,3> hitPair;
           hitPair[0] = Layer_tuple(hits[0]);
       hitPair[1] = Layer_tuple(hits[1]);
           hitPair[2] = Layer_tuple(hits[2]);
 
       //extracting the DetLayer of the hits
           const DetLayer * fLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[0]->det()->geographicalId());
           const DetLayer * sLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[1]->det()->geographicalId());
           const DetLayer * tLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[2]->det()->geographicalId());
 
       //converting FastTrackerRecHit hits to BaseTrackerRecHit
       std::vector<BaseTrackerRecHit const *> fHits{hits[0]};
       std::vector<BaseTrackerRecHit const *> sHits{hits[1]};
       std::vector<BaseTrackerRecHit const *> tHits{hits[2]};
 
       //forming the SeedingLayerSet for the hit doublets
       SeedingLayerSetsHits::SeedingLayerSet pairCandidate1, pairCandidate2;
           for(SeedingLayerSetsHits::SeedingLayerSet ls : *seedingLayer){
         SeedingLayerSetsHits::SeedingLayerSet pairCandidate;
             for(const auto p : layerPairs_){
               pairCandidate = ls.slice(p,p+2);
               if(p==0 && hitPair[0] == seedingLayerIds[pairCandidate[0].index()] && hitPair[1] == seedingLayerIds[pairCandidate[1].index()])
                 pairCandidate1=pairCandidate;
               if(p==1 && hitPair[1] == seedingLayerIds[pairCandidate[0].index()] && hitPair[2] == seedingLayerIds[pairCandidate[1].index()])
                 pairCandidate2=pairCandidate;
             }
           }
 
       //Important: hits of the layer to be added to LayerHitMapCache
       auto& layerCache = filler.layerHitMapCache();
 
       //doublets for CA triplets from the allowed layer pair combinations:(0,1),(1,2) and storing in filler
           const RecHitsSortedInPhi & firsthm = *layerCache.add(pairCandidate1[0], std::make_unique<RecHitsSortedInPhi>(fHits, trackingRegion_->origin(), fLayer));
           const RecHitsSortedInPhi & secondhm = *layerCache.add(pairCandidate1[1], std::make_unique<RecHitsSortedInPhi>(sHits, trackingRegion_->origin(), sLayer));
           HitDoublets res1(firsthm,secondhm);
       HitPairGeneratorFromLayerPair::doublets(*trackingRegion_,*fLayer,*sLayer,firsthm,secondhm,*eventSetup_,0,res1);
           filler.addDoublets(pairCandidate1, std::move(res1));
           const RecHitsSortedInPhi & thirdhm = *layerCache.add(pairCandidate2[1], std::make_unique<RecHitsSortedInPhi>(tHits, trackingRegion_->origin(), tLayer));
           HitDoublets res2(secondhm,thirdhm);
       HitPairGeneratorFromLayerPair::doublets(*trackingRegion_,*sLayer,*tLayer,secondhm,thirdhm,*eventSetup_,0,res2);
           filler.addDoublets(pairCandidate2, std::move(res2));
 
       std::vector<OrderedHitSeeds> tripletresult;                                
       tripletresult.resize(ihd.regionSize());
       for(auto& ntuplet : tripletresult)
         ntuplet.reserve(3);
       CAHitTriplGenerator_->hitNtuplets(ihd,tripletresult,*eventSetup_,*seedingLayer); //calling the function from the class, modifies tripletresult
           return !tripletresult[0].empty();
     }
     }
     //new for Phase1     
     if(CAHitQuadGenerator_)
     {
       if(hits.size() < 4)
     {
       throw cms::Exception("FastSimTracking") << "For the given configuration, SeedFinderSelector::pass requires at least 4 hits";
     }
 
       if(!seedingLayer)
     throw cms::Exception("FastSimTracking") << "ERROR: SeedingLayers pointer not set for CAHitQuadrupletGenerator";      
 
       SeedingLayerSetsHits & layers = *seedingLayer;
       //constructing IntermediateHitDoublets to be passed onto CAHitQuadrupletGenerator::hitNtuplets()
       IntermediateHitDoublets ihd(&layers);
       const TrackingRegion& tr_ = *trackingRegion_;
       auto filler = ihd.beginRegion(&tr_);
       
       //forming the SeedingLayerId of the hits
       std::array<SeedingLayerSetsBuilder::SeedingLayerId,4> hitPair;
       hitPair[0] = Layer_tuple(hits[0]);
       hitPair[1] = Layer_tuple(hits[1]);
       hitPair[2] = Layer_tuple(hits[2]);
       hitPair[3] = Layer_tuple(hits[3]);
 
       //extracting the DetLayer of the hits
       const DetLayer * fLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[0]->det()->geographicalId());
       const DetLayer * sLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[1]->det()->geographicalId());
       const DetLayer * tLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[2]->det()->geographicalId());
       const DetLayer * frLayer = measurementTracker_->geometricSearchTracker()->detLayer(hits[3]->det()->geographicalId());
 
       //converting FastTrackerRecHit hits to BaseTrackerRecHit
       std::vector<BaseTrackerRecHit const *> fHits{hits[0]};
       std::vector<BaseTrackerRecHit const *> sHits{hits[1]};
       std::vector<BaseTrackerRecHit const *> tHits{hits[2]};
       std::vector<BaseTrackerRecHit const *> frHits{hits[3]};
 
       //forming the SeedingLayerSet for the hit doublets     
       SeedingLayerSetsHits::SeedingLayerSet pairCandidate1, pairCandidate2, pairCandidate3;
       for(SeedingLayerSetsHits::SeedingLayerSet ls : *seedingLayer){
     SeedingLayerSetsHits::SeedingLayerSet pairCandidate;
         for(const auto p : layerPairs_){
           pairCandidate = ls.slice(p,p+2);
       if(p==0 && hitPair[0] == seedingLayerIds[pairCandidate[0].index()] && hitPair[1] == seedingLayerIds[pairCandidate[1].index()])
             pairCandidate1=pairCandidate;
           if(p==1 && hitPair[1] == seedingLayerIds[pairCandidate[0].index()] && hitPair[2] == seedingLayerIds[pairCandidate[1].index()])
             pairCandidate2=pairCandidate;
           if(p==2 && hitPair[2] == seedingLayerIds[pairCandidate[0].index()] && hitPair[3] == seedingLayerIds[pairCandidate[1].index()])
             pairCandidate3=pairCandidate;
         }
       }
       
       //Important: hits of the layer to be added to LayerHitMapCache
       auto& layerCache = filler.layerHitMapCache();
 
       //doublets for CA quadruplets from the allowed layer pair combinations:(0,1),(1,2),(2,3) and storing in filler 
       const RecHitsSortedInPhi & firsthm = *layerCache.add(pairCandidate1[0], std::make_unique<RecHitsSortedInPhi>(fHits, trackingRegion_->origin(), fLayer));
       const RecHitsSortedInPhi & secondhm = *layerCache.add(pairCandidate1[1], std::make_unique<RecHitsSortedInPhi>(sHits, trackingRegion_->origin(), sLayer));
       HitDoublets res1(firsthm,secondhm);
       HitPairGeneratorFromLayerPair::doublets(*trackingRegion_,*fLayer,*sLayer,firsthm,secondhm,*eventSetup_,0,res1);
       filler.addDoublets(pairCandidate1, std::move(res1));
       const RecHitsSortedInPhi & thirdhm = *layerCache.add(pairCandidate2[1], std::make_unique<RecHitsSortedInPhi>(tHits, trackingRegion_->origin(), tLayer));
       HitDoublets res2(secondhm,thirdhm);
       HitPairGeneratorFromLayerPair::doublets(*trackingRegion_,*sLayer,*tLayer,secondhm,thirdhm,*eventSetup_,0,res2);
       filler.addDoublets(pairCandidate2, std::move(res2));
       const RecHitsSortedInPhi & fourthhm = *layerCache.add(pairCandidate3[1], std::make_unique<RecHitsSortedInPhi>(frHits, trackingRegion_->origin(), frLayer));
       HitDoublets res3(thirdhm, fourthhm);
       HitPairGeneratorFromLayerPair::doublets(*trackingRegion_,*tLayer,*frLayer,thirdhm,fourthhm,*eventSetup_,0,res3);
       filler.addDoublets(pairCandidate3, std::move(res3));
       
       std::vector<OrderedHitSeeds> quadrupletresult;
       quadrupletresult.resize(ihd.regionSize());
       for(auto& ntuplet : quadrupletresult)
     ntuplet.reserve(4);
       CAHitQuadGenerator_->hitNtuplets(ihd,quadrupletresult,*eventSetup_,*seedingLayer); //calling the function from the class, modifies quadrupletresult
       return !quadrupletresult[0].empty();  
     }    
 
     return true;
     
 }