TrajectorySeedProducer Class Reference

Inheritance diagram for TrajectorySeedProducer:

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
	TrajectorySeedProducer (const edm::ParameterSet &conf)
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

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
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	trackerTopologyESToken_
edm::EDGetTokenT< edm::OwnVector< TrackingRegion > >	trackingRegionToken

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 58 of file TrajectorySeedProducer.cc.

Constructor & Destructor Documentation

TrajectorySeedProducer()

TrajectorySeedProducer::TrajectorySeedProducer

(

const edm::ParameterSet &

conf

)

regions

Definition at line 87 of file TrajectorySeedProducer.cc.

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

                                                                          : trackerTopologyESToken_(esConsumes()) {
  // 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 = SeedCreatorFactory::get()->create(seedCreatorName, seedCreatorPSet, consumesCollector());
}

Member Function Documentation

produce()

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

override

Definition at line 139 of file TrajectorySeedProducer.cc.

References _seedingTree, clone(), MillePedeFileConverter_cfg::e, edm::EventSetup::getData(), fastTrackingUtilities::hitIsMasked(), DetachedQuadStep_cff::hitMasks, hitMasksToken, edm::EDGetTokenT< T >::isUninitialized(), eostools::move(), nHitsPerSeed_, convertSQLitetoXML_cfg::output, edm::OwnVector< T, P >::push_back(), TrackCandidateProducer_cfi::recHitCombinations, recHitCombinationsToken, HLT_2022v12_cff::region, seedCreator, HLT_2022v12_cff::seedFinder, seedFinderSelector, fastTrackingUtilities::setRecHitCombinationIndex(), edm::OwnVector< T, P >::size(), trackerTopologyESToken_, and trackingRegionToken.

                                                                         {
  // services
  auto const& trackerTopology = es.getData(trackerTopologyESToken_);

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

Member Data Documentation

_seedingTree

SeedingTree<TrackingLayer> TrajectorySeedProducer::_seedingTree

private

Definition at line 71 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

hitMasksToken

edm::EDGetTokenT<std::vector<bool> > TrajectorySeedProducer::hitMasksToken

private

Definition at line 63 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

measurementTrackerLabel

std::string TrajectorySeedProducer::measurementTrackerLabel

private

Definition at line 74 of file TrajectorySeedProducer.cc.

nHitsPerSeed_

unsigned int TrajectorySeedProducer::nHitsPerSeed_

private

Definition at line 68 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

recHitCombinationsToken

edm::EDGetTokenT<FastTrackerRecHitCombinationCollection> TrajectorySeedProducer::recHitCombinationsToken

private

Definition at line 62 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

seedCreator

std::unique_ptr<SeedCreator> TrajectorySeedProducer::seedCreator

private

Definition at line 73 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

seedFinderSelector

std::unique_ptr<SeedFinderSelector> TrajectorySeedProducer::seedFinderSelector

private

Definition at line 76 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().

seedingLayers

std::vector<std::vector<TrackingLayer> > TrajectorySeedProducer::seedingLayers

private

Definition at line 70 of file TrajectorySeedProducer.cc.

trackerTopologyESToken_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> TrajectorySeedProducer::trackerTopologyESToken_

private

Definition at line 65 of file TrajectorySeedProducer.cc.

Referenced by produce().

trackingRegionToken

edm::EDGetTokenT<edm::OwnVector<TrackingRegion> > TrajectorySeedProducer::trackingRegionToken

private

Definition at line 64 of file TrajectorySeedProducer.cc.

Referenced by produce(), and TrajectorySeedProducer().