TrackstersProducer Class Reference

Inheritance diagram for TrackstersProducer:

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
	TrackstersProducer (const edm::ParameterSet &)
	~TrackstersProducer () override
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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
static void	globalEndJob (TrackstersCache *)
static std::unique_ptr< TrackstersCache >	initializeGlobalCache (const edm::ParameterSet &)

Private Attributes
const edm::EDGetTokenT< std::vector< reco::CaloCluster > >	clusters_token_
const edm::EDGetTokenT< edm::ValueMap< std::pair< float, float > > >	clustersTime_token_
std::string	detector_
bool	doNose_
const edm::EDGetTokenT< std::vector< float > >	filtered_layerclusters_mask_token_
std::unique_ptr< TracksterInferenceAlgoBase >	inferenceAlgo_
ticl::Trackster::IterationIndex	iterIndex_ = ticl::Trackster::IterationIndex(0)
const std::string	itername_
edm::EDGetTokenT< TICLLayerTilesHFNose >	layer_clusters_tiles_hfnose_token_
edm::EDGetTokenT< TICLLayerTiles >	layer_clusters_tiles_token_
std::unique_ptr< PatternRecognitionAlgoBaseT< TICLLayerTiles > >	myAlgo_
std::unique_ptr< PatternRecognitionAlgoBaseT< TICLLayerTilesHFNose > >	myAlgoHFNose_
const edm::EDGetTokenT< std::vector< float > >	original_layerclusters_mask_token_
const edm::EDGetTokenT< std::vector< TICLSeedingRegion > >	seeding_regions_token_

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 34 of file TrackstersProducer.cc.

Constructor & Destructor Documentation

TrackstersProducer()

TrackstersProducer::TrackstersProducer ( const edm::ParameterSet &  ps )

explicit

Definition at line 64 of file TrackstersProducer.cc.

References doNose_, ticl::Trackster::EM, get, edm::ParameterSet::getParameter(), ticl::Trackster::HAD, inferenceAlgo_, iterIndex_, itername_, layer_clusters_tiles_hfnose_token_, layer_clusters_tiles_token_, ticl::Trackster::MIP, myAlgo_, myAlgoHFNose_, HLT_2024v14_cff::plugin, AlCaHLTBitMon_QueryRunRegistry::string, ticl::Trackster::TRKEM, and ticl::Trackster::TRKHAD.

    : detector_(ps.getParameter<std::string>("detector")),
      doNose_(detector_ == "HFNose"),
      clusters_token_(consumes<std::vector<reco::CaloCluster>>(ps.getParameter<edm::InputTag>("layer_clusters"))),
      filtered_layerclusters_mask_token_(consumes<std::vector<float>>(ps.getParameter<edm::InputTag>("filtered_mask"))),
      original_layerclusters_mask_token_(consumes<std::vector<float>>(ps.getParameter<edm::InputTag>("original_mask"))),
      clustersTime_token_(
          consumes<edm::ValueMap<std::pair<float, float>>>(ps.getParameter<edm::InputTag>("time_layerclusters"))),
      seeding_regions_token_(
          consumes<std::vector<TICLSeedingRegion>>(ps.getParameter<edm::InputTag>("seeding_regions"))),
      itername_(ps.getParameter<std::string>("itername")) {
  auto plugin = ps.getParameter<std::string>("patternRecognitionBy");
  auto pluginPSet = ps.getParameter<edm::ParameterSet>("pluginPatternRecognitionBy" + plugin);
  if (doNose_) {
    myAlgoHFNose_ = PatternRecognitionHFNoseFactory::get()->create(
        ps.getParameter<std::string>("patternRecognitionBy"), pluginPSet, consumesCollector());
    layer_clusters_tiles_hfnose_token_ =
        consumes<TICLLayerTilesHFNose>(ps.getParameter<edm::InputTag>("layer_clusters_hfnose_tiles"));
  } else {
    myAlgo_ = PatternRecognitionFactory::get()->create(
        ps.getParameter<std::string>("patternRecognitionBy"), pluginPSet, consumesCollector());
    layer_clusters_tiles_token_ = consumes<TICLLayerTiles>(ps.getParameter<edm::InputTag>("layer_clusters_tiles"));
  }

  // Initialize inference algorithm using the factory
  std::string inferencePlugin = ps.getParameter<std::string>("inferenceAlgo");
  edm::ParameterSet inferencePSet = ps.getParameter<edm::ParameterSet>("pluginInferenceAlgo" + inferencePlugin);
  inferenceAlgo_ = std::unique_ptr<TracksterInferenceAlgoBase>(
      TracksterInferenceAlgoFactory::get()->create(inferencePlugin, inferencePSet));

  if (itername_ == "TrkEM")
    iterIndex_ = ticl::Trackster::TRKEM;
  else if (itername_ == "EM")
    iterIndex_ = ticl::Trackster::EM;
  else if (itername_ == "Trk")
    iterIndex_ = ticl::Trackster::TRKHAD;
  else if (itername_ == "HAD")
    iterIndex_ = ticl::Trackster::HAD;
  else if (itername_ == "MIP")
    iterIndex_ = ticl::Trackster::MIP;

  produces<std::vector<Trackster>>();
  produces<std::vector<float>>();  // Mask to be applied at the next iteration
}

~TrackstersProducer()

TrackstersProducer::~TrackstersProducer ( )

inlineoverride

Definition at line 37 of file TrackstersProducer.cc.

{}

Member Function Documentation

fillDescriptions()

void TrackstersProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 109 of file TrackstersProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addNode(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                    {
  // hgcalMultiClusters
  edm::ParameterSetDescription desc;
  desc.add<std::string>("detector", "HGCAL");
  desc.add<edm::InputTag>("layer_clusters", edm::InputTag("hgcalMergeLayerClusters"));
  desc.add<edm::InputTag>("filtered_mask", edm::InputTag("filteredLayerClusters", "iterationLabelGoesHere"));
  desc.add<edm::InputTag>("original_mask", edm::InputTag("hgcalMergeLayerClusters", "InitialLayerClustersMask"));
  desc.add<edm::InputTag>("time_layerclusters", edm::InputTag("hgcalMergeLayerClusters", "timeLayerCluster"));
  desc.add<edm::InputTag>("layer_clusters_tiles", edm::InputTag("ticlLayerTileProducer"));
  desc.add<edm::InputTag>("layer_clusters_hfnose_tiles", edm::InputTag("ticlLayerTileHFNose"));
  desc.add<edm::InputTag>("seeding_regions", edm::InputTag("ticlSeedingRegionProducer"));
  desc.add<std::string>("patternRecognitionBy", "CA");
  desc.add<std::string>("itername", "unknown");
  desc.add<std::string>("inferenceAlgo", "TracksterInferenceByDNN");

  // CA Plugin
  edm::ParameterSetDescription pluginDesc;
  pluginDesc.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "CA", true));
  desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByCA", pluginDesc);
  //
  // CLUE3D Plugin
  edm::ParameterSetDescription pluginDescClue3D;
  pluginDescClue3D.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "CLUE3D", true));
  desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByCLUE3D", pluginDescClue3D);

  // FastJet Plugin
  edm::ParameterSetDescription pluginDescFastJet;
  pluginDescFastJet.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "FastJet", true));
  desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByFastJet", pluginDescFastJet);

  // Recovery Plugin
  edm::ParameterSetDescription pluginDescRecovery;
  pluginDescRecovery.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "Recovery", true));
  desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByRecovery", pluginDescRecovery);

  // Inference Plugins
  edm::ParameterSetDescription inferenceDesc;
  inferenceDesc.addNode(edm::PluginDescription<TracksterInferenceAlgoFactory>("type", "TracksterInferenceByDNN", true));
  desc.add<edm::ParameterSetDescription>("pluginInferenceAlgoTracksterInferenceByDNN", inferenceDesc);

  edm::ParameterSetDescription inferenceDescANN;
  inferenceDescANN.addNode(
      edm::PluginDescription<TracksterInferenceAlgoFactory>("type", "TracksterInferenceByANN", true));
  desc.add<edm::ParameterSetDescription>("pluginInferenceAlgoTracksterInferenceByANN", inferenceDescANN);

  edm::ParameterSetDescription inferenceDescCNNv4;
  inferenceDescCNNv4.addNode(
      edm::PluginDescription<TracksterInferenceAlgoFactory>("type", "TracksterInferenceByCNNv4", true));
  desc.add<edm::ParameterSetDescription>("pluginInferenceAlgoTracksterInferenceByCNNv4", inferenceDescCNNv4);

  descriptions.add("trackstersProducer", desc);
}

globalEndJob()

static void TrackstersProducer::globalEndJob ( TrackstersCache *  )

static

initializeGlobalCache()

static std::unique_ptr<TrackstersCache> TrackstersProducer::initializeGlobalCache ( const edm::ParameterSet &  )

static

produce()

void TrackstersProducer::produce ( edm::Event &  evt, const edm::EventSetup &  es  )

override

Definition at line 162 of file TrackstersProducer.cc.

References clusters_token_, clustersTime_token_, filterCSVwithJSON::copy, doNose_, filtered_layerclusters_mask_token_, edm::Event::get(), mps_fire::i, inferenceAlgo_, input, iterIndex_, hltTiclTrackstersCLUE3DHigh_cfi::layer_clusters_hfnose_tiles, hltTiclTrackstersCLUE3DHigh_cfi::layer_clusters_tiles, layer_clusters_tiles_hfnose_token_, layer_clusters_tiles_token_, hltEgammaHGCALIDVarsL1Seeded_cfi::layerClusters, eostools::move(), myAlgo_, myAlgoHFNose_, original_layerclusters_mask_token_, edm::Event::put(), mps_fire::result, hltTiclTrackstersCLUE3DHigh_cfi::seeding_regions, seeding_regions_token_, and findQualityFiles::v.

                                                                       {
  auto result = std::make_unique<std::vector<Trackster>>();
  auto initialResult = std::make_unique<std::vector<Trackster>>();
  auto output_mask = std::make_unique<std::vector<float>>();

  const std::vector<float>& original_layerclusters_mask = evt.get(original_layerclusters_mask_token_);
  const auto& layerClusters = evt.get(clusters_token_);
  const auto& inputClusterMask = evt.get(filtered_layerclusters_mask_token_);
  const auto& layerClustersTimes = evt.get(clustersTime_token_);
  const auto& seeding_regions = evt.get(seeding_regions_token_);

  std::unordered_map<int, std::vector<int>> seedToTrackstersAssociation;
  // if it's regional iteration and there are seeding regions
  if (!seeding_regions.empty()) {
    if (seeding_regions[0].index != -1) {
      auto numberOfSeedingRegions = seeding_regions.size();
      for (unsigned int i = 0; i < numberOfSeedingRegions; ++i) {
        seedToTrackstersAssociation.emplace(seeding_regions[i].index, 0);
      }
    }

    if (doNose_) {
      const auto& layer_clusters_hfnose_tiles = evt.get(layer_clusters_tiles_hfnose_token_);
      const typename PatternRecognitionAlgoBaseT<TICLLayerTilesHFNose>::Inputs inputHFNose(
          evt, es, layerClusters, inputClusterMask, layerClustersTimes, layer_clusters_hfnose_tiles, seeding_regions);

      myAlgoHFNose_->makeTracksters(inputHFNose, *initialResult, seedToTrackstersAssociation);
      // Run inference algorithm
      inferenceAlgo_->inputData(layerClusters, *initialResult);
      inferenceAlgo_->runInference(*initialResult);
      myAlgoHFNose_->filter(*result, *initialResult, inputHFNose, seedToTrackstersAssociation);

    } else {
      const auto& layer_clusters_tiles = evt.get(layer_clusters_tiles_token_);
      const typename PatternRecognitionAlgoBaseT<TICLLayerTiles>::Inputs input(
          evt, es, layerClusters, inputClusterMask, layerClustersTimes, layer_clusters_tiles, seeding_regions);

      myAlgo_->makeTracksters(input, *initialResult, seedToTrackstersAssociation);
      // Run inference algorithm
      inferenceAlgo_->inputData(layerClusters, *initialResult);
      inferenceAlgo_->runInference(*initialResult);
      myAlgo_->filter(*result, *initialResult, input, seedToTrackstersAssociation);
    }
  }
  // Now update the global mask and put it into the event
  output_mask->reserve(original_layerclusters_mask.size());
  // Copy over the previous state
  std::copy(
      std::begin(original_layerclusters_mask), std::end(original_layerclusters_mask), std::back_inserter(*output_mask));

  for (auto& trackster : *result) {
    trackster.setIteration(iterIndex_);
    // Mask the used elements, accordingly
    for (auto const v : trackster.vertices()) {
      // TODO(rovere): for the moment we mask the layer cluster completely. In
      // the future, properly compute the fraction of usage.
      (*output_mask)[v] = 0.;
    }
  }

  evt.put(std::move(result));
  evt.put(std::move(output_mask));
}

Member Data Documentation

clusters_token_

const edm::EDGetTokenT<std::vector<reco::CaloCluster> > TrackstersProducer::clusters_token_

private

Definition at line 52 of file TrackstersProducer.cc.

Referenced by produce().

clustersTime_token_

const edm::EDGetTokenT<edm::ValueMap<std::pair<float, float> > > TrackstersProducer::clustersTime_token_

private

Definition at line 55 of file TrackstersProducer.cc.

Referenced by produce().

detector_

std::string TrackstersProducer::detector_

private

Definition at line 47 of file TrackstersProducer.cc.

doNose_

bool TrackstersProducer::doNose_

private

Definition at line 48 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

filtered_layerclusters_mask_token_

const edm::EDGetTokenT<std::vector<float> > TrackstersProducer::filtered_layerclusters_mask_token_

private

Definition at line 53 of file TrackstersProducer.cc.

Referenced by produce().

inferenceAlgo_

std::unique_ptr<TracksterInferenceAlgoBase> TrackstersProducer::inferenceAlgo_

private

Definition at line 51 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

iterIndex_

ticl::Trackster::IterationIndex TrackstersProducer::iterIndex_ = ticl::Trackster::IterationIndex(0)

private

Definition at line 60 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

itername_

const std::string TrackstersProducer::itername_

private

Definition at line 59 of file TrackstersProducer.cc.

Referenced by TrackstersProducer().

layer_clusters_tiles_hfnose_token_

edm::EDGetTokenT<TICLLayerTilesHFNose> TrackstersProducer::layer_clusters_tiles_hfnose_token_

private

Definition at line 57 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

layer_clusters_tiles_token_

edm::EDGetTokenT<TICLLayerTiles> TrackstersProducer::layer_clusters_tiles_token_

private

Definition at line 56 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

myAlgo_

std::unique_ptr<PatternRecognitionAlgoBaseT<TICLLayerTiles> > TrackstersProducer::myAlgo_

private

Definition at line 49 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

myAlgoHFNose_

std::unique_ptr<PatternRecognitionAlgoBaseT<TICLLayerTilesHFNose> > TrackstersProducer::myAlgoHFNose_

private

Definition at line 50 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

original_layerclusters_mask_token_

const edm::EDGetTokenT<std::vector<float> > TrackstersProducer::original_layerclusters_mask_token_

private

Definition at line 54 of file TrackstersProducer.cc.

Referenced by produce().

seeding_regions_token_

const edm::EDGetTokenT<std::vector<TICLSeedingRegion> > TrackstersProducer::seeding_regions_token_

private

Definition at line 58 of file TrackstersProducer.cc.

Referenced by produce().