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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 ( const edm::ParameterSet & conf )

regions

Definition at line 92 of file TrajectorySeedProducer.cc.

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

 {
     // 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 = std::unique_ptr<SeedCreator>{SeedCreatorFactory::get()->create( seedCreatorName, seedCreatorPSet)};
 
 }

Member Function Documentation

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

override

Definition at line 151 of file TrajectorySeedProducer.cc.

References _seedingTree, clone(), DEFINE_FWK_MODULE, edm::EventSetup::get(), edm::Event::getByToken(), fastTrackingUtilities::hitIsMasked(), DetachedQuadStep_cff::hitMasks, hitMasksToken, edm::EDGetTokenT< T >::isUninitialized(), eostools::move(), nHitsPerSeed_, nullptr, convertSQLitetoXML_cfg::output, edm::ESHandle< T >::product(), edm::OwnVector< T, P >::push_back(), edm::Event::put(), recHitCombinationsToken, seedCreator, particleFlowClusterECALUncorrected_cfi::seedFinder, seedFinderSelector, fastTrackingUtilities::setRecHitCombinationIndex(), edm::OwnVector< T, P >::size(), and trackingRegionToken.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

 {        
 
     // 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));
 
 }