Inheritance diagram for TrackingRecHitProducer:

Public Member Functions
void	beginRun (edm::Run const &, const edm::EventSetup &eventSetup) override

void	beginStream (edm::StreamID id) override

void	endStream () override

void	produce (edm::Event &event, const edm::EventSetup &eventSetup) override

	TrackingRecHitProducer (const edm::ParameterSet &config)

	~TrackingRecHitProducer () override

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

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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 ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

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, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	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 &	itemsToGetFrom (BranchType iType) 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 Member Functions
void	setupDetIdPipes (const edm::EventSetup &eventSetup)

Private Attributes
std::map< unsigned int, TrackingRecHitPipe >	_detIdPipes

edm::IOVSyncValue	_iovSyncValue

std::vector< SiPixelTemplateStore >	_pixelTempStore

std::vector< TrackingRecHitAlgorithm * >	_recHitAlgorithms

edm::EDGetTokenT< std::vector< PSimHit > >	_simHitToken

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
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

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 45 of file TrackingRecHitProducer.cc.

Constructor & Destructor Documentation

TrackingRecHitProducer::TrackingRecHitProducer ( const edm::ParameterSet & config )

Definition at line 71 of file TrackingRecHitProducer.cc.

References _recHitAlgorithms, _simHitToken, edm::EDConsumerBase::consumesCollector(), edm::ParameterSet::dump(), Exception, reco::get(), edm::ParameterSet::getParameter(), validationMuonRPCDigis_cfi::simHitTag, and AlCaHLTBitMon_QueryRunRegistry::string.

 {
     edm::ConsumesCollector consumeCollector = consumesCollector();
     const std::vector<edm::ParameterSet>& pluginConfigs = config.getParameter<std::vector<edm::ParameterSet>>("plugins");
 
     for (unsigned int iplugin = 0; iplugin<pluginConfigs.size(); ++iplugin)
     {
         const edm::ParameterSet& pluginConfig = pluginConfigs[iplugin];
         const std::string pluginType = pluginConfig.getParameter<std::string>("type");
         const std::string pluginName = pluginConfig.getParameter<std::string>("name");
 
         TrackingRecHitAlgorithm* recHitAlgorithm = TrackingRecHitAlgorithmFactory::get()->tryToCreate(pluginType,pluginName,pluginConfig,consumeCollector);
         if (recHitAlgorithm)
         {
             edm::LogInfo("TrackingRecHitProducer: ")<< "adding plugin type '"<<pluginType<<"' as '"<<pluginName<<"'"<<std::endl;
             _recHitAlgorithms.push_back(recHitAlgorithm);
         }
         else
         {
             throw cms::Exception("TrackingRecHitAlgorithm plugin not found: ") << "plugin type = "<<pluginType<<"\nconfiguration=\n"<<pluginConfig.dump();
         }
     }
 
     edm::InputTag simHitTag = config.getParameter<edm::InputTag>("simHits");
     _simHitToken = consumes<std::vector<PSimHit>>(simHitTag);
 
     produces<FastTrackerRecHitCollection>();
     produces<FastTrackerRecHitRefCollection>("simHit2RecHitMap");
 }

TrackingRecHitProducer::~TrackingRecHitProducer ( )

override

Definition at line 101 of file TrackingRecHitProducer.cc.

References _pixelTempStore, _recHitAlgorithms, patPFMETCorrections_cff::algo, and x.

 {
     for (TrackingRecHitAlgorithm* algo: _recHitAlgorithms)
     {
         delete algo;
     }
     _recHitAlgorithms.clear();
 
     //--- Delete the templates. This is safe even if thePixelTemp_ vector is empty.
     for (auto x : _pixelTempStore) x.destroy();
 }

Member Function Documentation

void TrackingRecHitProducer::beginRun	(	edm::Run const &	run,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 122 of file TrackingRecHitProducer.cc.

References _pixelTempStore, _recHitAlgorithms, patPFMETCorrections_cff::algo, Exception, edm::EventSetup::get(), edm::ESHandle< T >::product(), and SiPixelTemplate::pushfile().

 {
     //--- Since all pixel algorithms (of which there could be several) use the same
     //    templateStore, filled out from the same DB Object, we need to it centrally
     //    (namely here), and then distribute it to the algorithms.  Note that only
     //    the pixel algorithms implement beginRun(), for the strip tracker this defaults
     //    to a no-op.
 
     edm::ESHandle<SiPixelTemplateDBObject> templateDBobject;
     eventSetup.get<SiPixelTemplateDBObjectESProducerRcd>().get(templateDBobject);
     const SiPixelTemplateDBObject * pixelTemplateDBObject = templateDBobject.product();
   
     //--- Now that we have the DB object, load the correct templates from the DB.  
     //    (They are needed for data and full sim MC, so in a production FastSim
     //    run, everything should already be in the DB.)
     if ( !SiPixelTemplate::pushfile( *pixelTemplateDBObject, _pixelTempStore ) ) {
          throw cms::Exception("TrackingRecHitProducer:")
        << "SiPixel Templates not loaded correctly from the DB object!" << std::endl;
     }
 
     for (TrackingRecHitAlgorithm* algo: _recHitAlgorithms)
     {
       algo->beginRun(run, eventSetup, pixelTemplateDBObject, _pixelTempStore );
     }
 }

void TrackingRecHitProducer::beginStream ( edm::StreamID id )

overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 114 of file TrackingRecHitProducer.cc.

References _recHitAlgorithms, and patPFMETCorrections_cff::algo.

 {
     for (TrackingRecHitAlgorithm* algo: _recHitAlgorithms)
     {
         algo->beginStream(id);
     }
 }

void TrackingRecHitProducer::endStream ( )

overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 274 of file TrackingRecHitProducer.cc.

References _recHitAlgorithms, patPFMETCorrections_cff::algo, and DEFINE_FWK_MODULE.

 {
     for (TrackingRecHitAlgorithm* algo: _recHitAlgorithms)
     {
         algo->endStream();
     }
 }

void TrackingRecHitProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 189 of file TrackingRecHitProducer.cc.

References _detIdPipes, _recHitAlgorithms, _simHitToken, patPFMETCorrections_cff::algo, PSimHit::detUnitId(), Exception, plotBeamSpotDB::first, eostools::move(), TrackingRecHitPipe::produce(), setupDetIdPipes(), rpcPointValidation_cfi::simHit, trackerHits::simHits, and edm::OwnVector< T, P >::size().

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

 {
 
 
     //resetup pipes if new iov
     setupDetIdPipes(eventSetup);
     //begin event
     for (TrackingRecHitAlgorithm* algo: _recHitAlgorithms)
     {
         algo->beginEvent(event,eventSetup);
     }
 
     //build DetId -> PSimHit map
     edm::Handle<std::vector<PSimHit>> simHits;
     event.getByToken(_simHitToken,simHits);
 
     std::unique_ptr<FastTrackerRecHitCollection> output_recHits(new FastTrackerRecHitCollection);
     output_recHits->reserve(simHits->size());
 
     edm::RefProd<FastTrackerRecHitCollection> output_recHits_refProd = event.getRefBeforePut<FastTrackerRecHitCollection>();
     std::unique_ptr<FastTrackerRecHitRefCollection> output_recHitRefs(new FastTrackerRecHitRefCollection(simHits->size(),FastTrackerRecHitRef()));
 
     std::map<unsigned int,std::vector<std::pair<unsigned int,const PSimHit*>>> simHitsIdPairPerDetId;
     for (unsigned int ihit = 0; ihit < simHits->size(); ++ihit)
     {
         const PSimHit* simHit = &(*simHits)[ihit];
         simHitsIdPairPerDetId[simHit->detUnitId()].push_back(std::make_pair(ihit,simHit));
     }
 
     for (auto simHitsIdPairIt = simHitsIdPairPerDetId.begin(); simHitsIdPairIt != simHitsIdPairPerDetId.end(); ++simHitsIdPairIt)
     {
         const DetId& detId = simHitsIdPairIt->first;
         std::map<unsigned int, TrackingRecHitPipe>::const_iterator pipeIt = _detIdPipes.find(detId);
         if (pipeIt!=_detIdPipes.cend())
         {
             auto& simHitIdPairList = simHitsIdPairIt->second;
             const TrackingRecHitPipe& pipe = pipeIt->second;
 
             TrackingRecHitProductPtr product = std::make_shared<TrackingRecHitProduct>(detId,simHitIdPairList);
 
             product = pipe.produce(product);
 
             const std::vector<TrackingRecHitProduct::RecHitToSimHitIdPairs>& recHitToSimHitIdPairsList = product->getRecHitToSimHitIdPairs();
 
 
             for (unsigned int irecHit = 0; irecHit < recHitToSimHitIdPairsList.size(); ++irecHit)
             {
                 output_recHits->push_back(recHitToSimHitIdPairsList[irecHit].first);
                 const std::vector<TrackingRecHitProduct::SimHitIdPair>& simHitIdPairList = recHitToSimHitIdPairsList[irecHit].second;
                 for (unsigned int isimHit = 0; isimHit < simHitIdPairList.size(); ++isimHit)
                 {
                     unsigned int simHitId = simHitIdPairList[isimHit].first;
                     if (not (*output_recHitRefs)[simHitId].isNull())
                     {
                         throw cms::Exception("FastSimulation/TrackingRecHitProducer","A PSimHit cannot lead to multiple FastTrackerRecHits");
                     }
                     (*output_recHitRefs)[simHitId] = FastTrackerRecHitRef(output_recHits_refProd,output_recHits->size()-1);
                 }
             }
         }
         else
         {
             //there should be at least an empty pipe for each DetId
             throw cms::Exception("FastSimulation/TrackingRecHitProducer","A PSimHit carries a DetId which does not belong to the TrackerGeometry: "+std::to_string(detId));
         }
     }
 
     //end event
     for (TrackingRecHitAlgorithm* algo: _recHitAlgorithms)
     {
         algo->endEvent(event,eventSetup);
     }
 
     // note from lukas:
     // all rechits need a unique id numbers
     for(unsigned recHitIndex = 0; recHitIndex < output_recHits->size(); ++recHitIndex)
     {
         ((FastSingleTrackerRecHit*)&(*output_recHits)[recHitIndex])->setId(recHitIndex);
     }
 
     event.put(std::move(output_recHits));
     event.put(std::move(output_recHitRefs),"simHit2RecHitMap");
 
 }

void TrackingRecHitProducer::setupDetIdPipes ( const edm::EventSetup & eventSetup )

private

Definition at line 148 of file TrackingRecHitProducer.cc.

References _detIdPipes, _iovSyncValue, _recHitAlgorithms, TrackingRecHitPipe::addAlgorithm(), patPFMETCorrections_cff::algo, TrackerGeometry::detIds(), Exception, edm::EventSetup::get(), TrackingRecHitAlgorithm::getSelectionString(), edm::EventSetup::iovSyncValue(), TrackerDetIdSelector::passSelection(), pipe::pipe(), TrackerTopology::print(), edm::ESHandle< T >::product(), and TrackingRecHitPipe::size().

Referenced by produce().

 {
     if (_iovSyncValue!=eventSetup.iovSyncValue())
     {
         _iovSyncValue=eventSetup.iovSyncValue();
         edm::ESHandle<TrackerGeometry> trackerGeometryHandle;
         edm::ESHandle<TrackerTopology> trackerTopologyHandle;
         eventSetup.get<TrackerDigiGeometryRecord>().get(trackerGeometryHandle);
         eventSetup.get<TrackerTopologyRcd>().get(trackerTopologyHandle);
         const TrackerGeometry* trackerGeometry = trackerGeometryHandle.product();
         const TrackerTopology* trackerTopology = trackerTopologyHandle.product();
 
         _detIdPipes.clear();
 
         //build pipes for all detIds
         const std::vector<DetId>& detIds = trackerGeometry->detIds();
         std::vector<unsigned int> numberOfDetIdsPerAlgorithm(_recHitAlgorithms.size(),0);
 
         for (const DetId& detId: detIds)
         {
             TrackerDetIdSelector selector(detId,*trackerTopology);
 
             TrackingRecHitPipe pipe;
             for (unsigned int ialgo = 0; ialgo < _recHitAlgorithms.size(); ++ialgo)
             {
                 TrackingRecHitAlgorithm* algo = _recHitAlgorithms[ialgo];
                 if (selector.passSelection(algo->getSelectionString()))
                 {
                     numberOfDetIdsPerAlgorithm[ialgo]+=1;
                     pipe.addAlgorithm(algo);
                 }
             }
             if (pipe.size()==0)
             {
                 throw cms::Exception("FastSimulation/TrackingRecHitProducer: DetId not configured! ("+trackerTopology->print(detId)+")");
             }
             _detIdPipes[detId.rawId()]=pipe;
         }
     }
 }