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

	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
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<>
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 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(), phase1PixelTopology::layer, 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));
 }