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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
void	setupDetIdPipes (const edm::EventSetup &eventSetup)

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

std::vector< SiPixelTemplateStore >	_pixelTempStore

std::vector< std::unique_ptr< TrackingRecHitAlgorithm > >	_recHitAlgorithms

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

unsigned long long	_trackerGeometryCacheID = 0

unsigned long long	_trackerTopologyCacheID = 0

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

Constructor & Destructor Documentation

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

Definition at line 68 of file TrackingRecHitProducer.cc.

References _recHitAlgorithms, _simHitToken, edm::ParameterSet::dump(), Exception, timingPdfMaker::get, edm::ParameterSet::getParameter(), eostools::move(), TrackingRecHitProducer_cfi::pluginConfig, 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");
 
     std::unique_ptr<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(std::move(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 97 of file TrackingRecHitProducer.cc.

References _pixelTempStore, and x.

                                                 {
   //--- 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 109 of file TrackingRecHitProducer.cc.

References _pixelTempStore, _recHitAlgorithms, ecalcalib_dqm_sourceclient-live_cfg::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 (auto& algo : _recHitAlgorithms) {
     algo->beginRun(run, eventSetup, pixelTemplateDBObject, _pixelTempStore);
   }
 }

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

override

Definition at line 103 of file TrackingRecHitProducer.cc.

References _recHitAlgorithms, and ecalcalib_dqm_sourceclient-live_cfg::algo.

                                                        {
   for (auto& algo : _recHitAlgorithms) {
     algo->beginStream(id);
   }
 }

void TrackingRecHitProducer::endStream ( )

override

Definition at line 255 of file TrackingRecHitProducer.cc.

References _recHitAlgorithms, ecalcalib_dqm_sourceclient-live_cfg::algo, and DEFINE_FWK_MODULE.

                                        {
   for (auto& algo : _recHitAlgorithms) {
     algo->endStream();
   }
 }

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

override

Definition at line 173 of file TrackingRecHitProducer.cc.

References _detIdPipes, _recHitAlgorithms, _simHitToken, ecalcalib_dqm_sourceclient-live_cfg::algo, PSimHit::detUnitId(), PSimHit::energyLoss(), Exception, dqmdumpme::first, eostools::move(), TrackingRecHitPipe::produce(), setupDetIdPipes(), rpcPointValidation_cfi::simHit, FastTrackerRecHitCombiner_cfi::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 (auto& algo : _recHitAlgorithms) {
     algo->beginEvent(event, eventSetup);
   }
 
   //build DetId -> PSimHit map
   edm::Handle<std::vector<PSimHit>> simHits;
   event.getByToken(_simHitToken, simHits);
 
   auto output_recHits = std::make_unique<FastTrackerRecHitCollection>();
   output_recHits->reserve(simHits->size());
 
   edm::RefProd<FastTrackerRecHitCollection> output_recHits_refProd =
       event.getRefBeforePut<FastTrackerRecHitCollection>();
   auto output_recHitRefs = std::make_unique<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;
         double energyLoss_tot = 0;  //
         for (unsigned int isimHit = 0; isimHit < simHitIdPairList.size(); ++isimHit) {
           unsigned int simHitId = simHitIdPairList[isimHit].first;
           const PSimHit* simHit = simHitIdPairList[isimHit].second;
           energyLoss_tot +=
               simHit
                   ->energyLoss();  //energy loss of sim hit in GeV std::cout << "energyLoss_tot" << energyLoss_tot << std::endl;
           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);
         }
         static_cast<FastSingleTrackerRecHit&>(output_recHits->back()).setEnergyLoss(energyLoss_tot);
       }
     } 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 (auto& 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 133 of file TrackingRecHitProducer.cc.

References _detIdPipes, _recHitAlgorithms, _trackerGeometryCacheID, _trackerTopologyCacheID, TrackingRecHitPipe::addAlgorithm(), ecalcalib_dqm_sourceclient-live_cfg::algo, edm::eventsetup::EventSetupRecord::cacheIdentifier(), TrackerGeometry::detIds(), Exception, edm::EventSetup::get(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), or, TrackerDetIdSelector::passSelection(), pipe::pipe(), TrackerTopology::print(), edm::ESHandle< T >::product(), and TrackingRecHitPipe::size().

Referenced by produce().

                                                                             {
   auto const& trackerGeomRec = eventSetup.get<TrackerDigiGeometryRecord>();
   auto const& trackerTopoRec = eventSetup.get<TrackerTopologyRcd>();
   if (trackerGeomRec.cacheIdentifier() != _trackerGeometryCacheID or
       trackerTopoRec.cacheIdentifier() != _trackerTopologyCacheID) {
     _trackerGeometryCacheID = trackerGeomRec.cacheIdentifier();
     _trackerTopologyCacheID = trackerTopoRec.cacheIdentifier();
     edm::ESHandle<TrackerGeometry> trackerGeometryHandle;
     edm::ESHandle<TrackerTopology> trackerTopologyHandle;
     trackerGeomRec.get(trackerGeometryHandle);
     trackerTopoRec.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) {
         auto& algo = _recHitAlgorithms[ialgo];
         if (selector.passSelection(algo->getSelectionString())) {
           numberOfDetIdsPerAlgorithm[ialgo] += 1;
           pipe.addAlgorithm(algo.get());
         }
       }
       if (pipe.size() == 0) {
         throw cms::Exception("FastSimulation/TrackingRecHitProducer: DetId not configured! (" +
                              trackerTopology->print(detId) + ")");
       }
       _detIdPipes[detId.rawId()] = pipe;
     }
   }
 }