TrackingRecHitProducer Class Reference

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::TrackingRecHitProducer

(

const edm::ParameterSet &

config

)

Definition at line 68 of file TrackingRecHitProducer.cc.

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

References _recHitAlgorithms, _simHitToken, Exception, get, eostools::move(), TrackingRecHitProducer_cfi::pluginConfig, validationMuonRPCDigis_cfi::simHitTag, and AlCaHLTBitMon_QueryRunRegistry::string.

~TrackingRecHitProducer()

TrackingRecHitProducer::~TrackingRecHitProducer ( )

override

Definition at line 97 of file TrackingRecHitProducer.cc.

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

References _pixelTempStore, and x.

Member Function Documentation

beginRun()

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

override

Definition at line 109 of file TrackingRecHitProducer.cc.

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

References _pixelTempStore, _recHitAlgorithms, options_cfi::eventSetup, Exception, get, edm::ESHandle< T >::product(), SiPixelTemplate::pushfile(), and writedatasetfile::run.

beginStream()

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

override

Definition at line 103 of file TrackingRecHitProducer.cc.

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

References _recHitAlgorithms.

endStream()

void TrackingRecHitProducer::endStream ( )

override

Definition at line 255 of file TrackingRecHitProducer.cc.

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

References _recHitAlgorithms.

produce()

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

override

Definition at line 173 of file TrackingRecHitProducer.cc.

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

References _detIdPipes, _recHitAlgorithms, _simHitToken, options_cfi::eventSetup, Exception, dqmdumpme::first, eostools::move(), setupDetIdPipes(), rpcPointValidation_cfi::simHit, FastTrackerRecHitCombiner_cfi::simHits, and edm::OwnVector< T, P >::size().

setupDetIdPipes()

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

private

Definition at line 133 of file TrackingRecHitProducer.cc.

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

References _detIdPipes, _recHitAlgorithms, _trackerGeometryCacheID, _trackerTopologyCacheID, edm::eventsetup::EventSetupRecord::cacheIdentifier(), options_cfi::eventSetup, Exception, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), or, TrackerDetIdSelector::passSelection(), pipe::pipe(), edm::ESHandle< T >::product(), trackerGeometry_cfi::trackerGeometry, and trackerTopology_cfi::trackerTopology.

Referenced by produce().

Member Data Documentation

_detIdPipes

std::map<unsigned int, TrackingRecHitPipe> TrackingRecHitProducer::_detIdPipes

private

Definition at line 50 of file TrackingRecHitProducer.cc.

Referenced by produce(), and setupDetIdPipes().

_pixelTempStore

std::vector<SiPixelTemplateStore> TrackingRecHitProducer::_pixelTempStore

private

Definition at line 52 of file TrackingRecHitProducer.cc.

Referenced by beginRun(), and ~TrackingRecHitProducer().

_recHitAlgorithms

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

private

Definition at line 47 of file TrackingRecHitProducer.cc.

Referenced by beginRun(), beginStream(), endStream(), produce(), setupDetIdPipes(), and TrackingRecHitProducer().

_simHitToken

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

private

Definition at line 46 of file TrackingRecHitProducer.cc.

Referenced by produce(), and TrackingRecHitProducer().

_trackerGeometryCacheID

unsigned long long TrackingRecHitProducer::_trackerGeometryCacheID = 0

private

Definition at line 48 of file TrackingRecHitProducer.cc.

Referenced by setupDetIdPipes().

_trackerTopologyCacheID

unsigned long long TrackingRecHitProducer::_trackerTopologyCacheID = 0

private

Definition at line 49 of file TrackingRecHitProducer.cc.

Referenced by setupDetIdPipes().