Inheritance diagram for TrajectorySeedProducer:

Public Member Functions
void	produce (edm::Event &e, const edm::EventSetup &es) override

	TrajectorySeedProducer (const edm::ParameterSet &conf)

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
SeedingTree< TrackingLayer >	_seedingTree

edm::EDGetTokenT< std::vector< bool > >	hitMasksToken

std::string	measurementTrackerLabel

unsigned int	nHitsPerSeed_

edm::EDGetTokenT< FastTrackerRecHitCombinationCollection >	recHitCombinationsToken

std::unique_ptr< SeedCreator >	seedCreator

std::unique_ptr< SeedFinderSelector >	seedFinderSelector

std::vector< std::vector< TrackingLayer > >	seedingLayers

edm::EDGetTokenT< edm::OwnVector< TrackingRegion > >	trackingRegionToken

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 59 of file TrajectorySeedProducer.cc.

Constructor & Destructor Documentation

◆ TrajectorySeedProducer()

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

regions

Definition at line 87 of file TrajectorySeedProducer.cc.

                                                                           {
   // products
   produces<TrajectorySeedCollection>();
  
   // consumes
   recHitCombinationsToken =
       consumes<FastTrackerRecHitCombinationCollection>(conf.getParameter<edm::InputTag>("recHitCombinations"));
   if (conf.exists("hitMasks")) {
     hitMasksToken = consumes<std::vector<bool>>(conf.getParameter<edm::InputTag>("hitMasks"));
   }
  
   // read Layers
   std::vector<std::string> layerStringList =
       conf.getParameter<edm::ParameterSet>("seedFinderSelector").getParameter<std::vector<std::string>>("layerList");
   std::string layerBegin = *(layerStringList.cbegin());
   nHitsPerSeed_ = 0;
   for (auto it = layerStringList.cbegin(); it < layerStringList.cend(); ++it) {
     std::vector<TrackingLayer> trackingLayerList;
     std::string line = *it;
     std::string::size_type pos = 0;
     unsigned int nHitsPerSeed = 0;
     while (pos != std::string::npos) {
       pos = line.find("+");
       std::string layer = line.substr(0, pos);
       TrackingLayer layerSpec = TrackingLayer::createFromString(layer);
       trackingLayerList.push_back(layerSpec);
       line = line.substr(pos + 1, std::string::npos);
       nHitsPerSeed++;
     }
     if (it == layerStringList.cbegin()) {
       nHitsPerSeed_ = nHitsPerSeed;
     } else if (nHitsPerSeed_ != nHitsPerSeed) {
       throw cms::Exception("FastSimTracking") << "All allowed seed layer definitions must have same elements";
     }
     _seedingTree.insert(trackingLayerList);
   }
  
   // seed finder selector
   if (conf.exists("seedFinderSelector")) {
     seedFinderSelector = std::make_unique<SeedFinderSelector>(
         conf.getParameter<edm::ParameterSet>("seedFinderSelector"), consumesCollector());
   }
  
   trackingRegionToken = consumes<edm::OwnVector<TrackingRegion>>(conf.getParameter<edm::InputTag>("trackingRegions"));
  
   // seed creator
   const edm::ParameterSet& seedCreatorPSet = conf.getParameter<edm::ParameterSet>("SeedCreatorPSet");
   std::string seedCreatorName = seedCreatorPSet.getParameter<std::string>("ComponentName");
   seedCreator = SeedCreatorFactory::get()->create(seedCreatorName, seedCreatorPSet);
 }

References _seedingTree, TrackingLayer::createFromString(), Exception, edm::ParameterSet::exists(), get, edm::ParameterSet::getParameter(), hitMasksToken, SeedingTree< DATA >::insert(), mps_splice::line, nHitsPerSeed_, recHitCombinationsToken, seedCreator, seedFinderSelector, AlCaHLTBitMon_QueryRunRegistry::string, and trackingRegionToken.

Member Function Documentation

◆ produce()

void TrajectorySeedProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	es
	)

override

Definition at line 139 of file TrajectorySeedProducer.cc.

                                                                          {
   // services
   edm::ESHandle<TrackerTopology> trackerTopology;
  
   es.get<TrackerTopologyRcd>().get(trackerTopology);
  
   // input data
   edm::Handle<FastTrackerRecHitCombinationCollection> recHitCombinations;
   e.getByToken(recHitCombinationsToken, recHitCombinations);
   const std::vector<bool>* hitMasks = nullptr;
   if (!hitMasksToken.isUninitialized()) {
     edm::Handle<std::vector<bool>> hitMasksHandle;
     e.getByToken(hitMasksToken, hitMasksHandle);
     hitMasks = &(*hitMasksHandle);
   }
  
   // output data
   std::unique_ptr<TrajectorySeedCollection> output(new TrajectorySeedCollection());
  
   // read the regions;
   edm::Handle<edm::OwnVector<TrackingRegion>> hregions;
   e.getByToken(trackingRegionToken, hregions);
   const auto& regions = *hregions;
   // and make sure there is at least one region
   if (regions.empty()) {
     e.put(std::move(output));
     return;
   }
  
   // instantiate the seed finder
   SeedFinder seedFinder(_seedingTree, *trackerTopology.product());
   if (seedFinderSelector) {
     seedFinderSelector->initEvent(e, es);
     seedFinder.addHitSelector(seedFinderSelector.get(), nHitsPerSeed_);
   }
  
   // loop over the combinations
   for (unsigned icomb = 0; icomb < recHitCombinations->size(); ++icomb) {
     FastTrackerRecHitCombination recHitCombination = (*recHitCombinations)[icomb];
  
     // create a list of hits cleaned from masked hits
     std::vector<const FastTrackerRecHit*> seedHitCandidates;
     for (const auto& _hit : recHitCombination) {
       if (hitMasks && fastTrackingUtilities::hitIsMasked(_hit.get(), *hitMasks)) {
         continue;
       }
       seedHitCandidates.push_back(_hit.get());
     }
  
     // loop over the regions
     for (const auto& region : regions) {
       // set the region used in the selector
       if (seedFinderSelector) {
         seedFinderSelector->setTrackingRegion(&region);
       }
  
       // find hits compatible with the seed requirements
       std::vector<unsigned int> seedHitNumbers = seedFinder.getSeed(seedHitCandidates);
  
       // create a seed from those hits
       if (seedHitNumbers.size() > 1) {
         // copy the hits
         edm::OwnVector<FastTrackerRecHit> seedHits;
         for (unsigned iIndex = 0; iIndex < seedHitNumbers.size(); ++iIndex) {
           seedHits.push_back(seedHitCandidates[seedHitNumbers[iIndex]]->clone());
         }
         // make them aware of the combination they originate from
         fastTrackingUtilities::setRecHitCombinationIndex(seedHits, icomb);
  
         // create the seed
         seedCreator->init(region, es, nullptr);
         seedCreator->makeSeed(*output,
                               SeedingHitSet(&seedHits[0],
                                             &seedHits[1],
                                             seedHits.size() >= 3 ? &seedHits[2] : nullptr,
                                             seedHits.size() >= 4 ? &seedHits[3] : nullptr));
         break;  // break the loop over the regions
       }
     }
   }
   e.put(std::move(output));
 }