Inheritance diagram for TrajectorySeedProducer:

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

	TrajectorySeedProducer (const edm::ParameterSet &conf)

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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, edm::EDConsumerBase::consumesCollector(), beamerCreator::create(), TrackingLayer::createFromString(), Exception, edm::ParameterSet::exists(), reco::get(), edm::ParameterSet::getParameter(), hitMasksToken, SeedingTree< DATA >::insert(), geometryCSVtoXML::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<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.reset(new 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.reset(SeedCreatorFactory::get()->create( seedCreatorName, seedCreatorPSet));
 
 }

Member Function Documentation

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

virtual

Definition at line 151 of file TrajectorySeedProducer.cc.

References _seedingTree, clone(), DEFINE_FWK_MODULE, edm::EventSetup::get(), edm::Event::getByToken(), fastTrackingUtilities::hitIsMasked(), 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 = 0;
     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.size() == 0)
     {
         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,0);
                 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));
 
 }