TrackstersProducer Class Reference

Inheritance diagram for TrackstersProducer:

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
	TrackstersProducer (const edm::ParameterSet &, const TrackstersCache *)
	~TrackstersProducer () override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< TrackstersCache > >
	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_
ticl::Trackster::IterationIndex	iterIndex_
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< edm::GlobalCache< TrackstersCache > >
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 32 of file TrackstersProducer.cc.

Constructor & Destructor Documentation

TrackstersProducer()

TrackstersProducer::TrackstersProducer ( const edm::ParameterSet &  ps, const TrackstersCache *  cache  )

explicit

Definition at line 81 of file TrackstersProducer.cc.

    : 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, cache, 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, cache, consumesCollector());
    layer_clusters_tiles_token_ = consumes<TICLLayerTiles>(ps.getParameter<edm::InputTag>("layer_clusters_tiles"));
  }
 
  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
}

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

~TrackstersProducer()

TrackstersProducer::~TrackstersProducer ( )

inlineoverride

Definition at line 35 of file TrackstersProducer.cc.

{}

Member Function Documentation

fillDescriptions()

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

static

Definition at line 120 of file TrackstersProducer.cc.

                                                                                    {
  // hgcalMultiClusters
  edm::ParameterSetDescription desc;
  desc.add<std::string>("detector", "HGCAL");
  desc.add<edm::InputTag>("layer_clusters", edm::InputTag("hgcalLayerClusters"));
  desc.add<edm::InputTag>("filtered_mask", edm::InputTag("filteredLayerClusters", "iterationLabelGoesHere"));
  desc.add<edm::InputTag>("original_mask", edm::InputTag("hgcalLayerClusters", "InitialLayerClustersMask"));
  desc.add<edm::InputTag>("time_layerclusters", edm::InputTag("hgcalLayerClusters", "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>("eid_graph_path", "RecoHGCal/TICL/data/tf_models/energy_id_v0.pb");
  desc.add<std::string>("itername", "unknown");
 
  // CA Plugin
  edm::ParameterSetDescription pluginDesc;
  pluginDesc.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "CA", true));
 
  // CLUE3D Plugin
  desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByCA", pluginDesc);
  edm::ParameterSetDescription pluginDescClue3D;
  pluginDescClue3D.addNode(edm::PluginDescription<PatternRecognitionFactory>("type", "CLUE3D", true));
  desc.add<edm::ParameterSetDescription>("pluginPatternRecognitionByCLUE3D", pluginDescClue3D);
 
  descriptions.add("trackstersProducer", desc);
}

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

globalEndJob()

void TrackstersProducer::globalEndJob ( TrackstersCache *  cache )

static

Definition at line 76 of file TrackstersProducer.cc.

                                                            {
  delete cache->eidGraphDef;
  cache->eidGraphDef = nullptr;
}

References utilities::cache().

initializeGlobalCache()

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

static

Definition at line 62 of file TrackstersProducer.cc.

                                                                                                      {
  // this method is supposed to create, initialize and return a TrackstersCache instance
  std::unique_ptr<TrackstersCache> cache = std::make_unique<TrackstersCache>(params);
 
  // load the graph def and save it
  std::string graphPath = params.getParameter<std::string>("eid_graph_path");
  if (!graphPath.empty()) {
    graphPath = edm::FileInPath(graphPath).fullPath();
    cache->eidGraphDef = tensorflow::loadGraphDef(graphPath);
  }
 
  return cache;
}

References utilities::cache(), edm::FileInPath::fullPath(), tensorflow::loadGraphDef(), CalibrationSummaryClient_cfi::params, and AlCaHLTBitMon_QueryRunRegistry::string.

produce()

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

override

Definition at line 148 of file TrackstersProducer.cc.

                                                                       {
  auto result = 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() and 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, *result, 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, *result, 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));
}

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

Member Data Documentation

clusters_token_

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

private

Definition at line 50 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 53 of file TrackstersProducer.cc.

Referenced by produce().

detector_

std::string TrackstersProducer::detector_

private

Definition at line 45 of file TrackstersProducer.cc.

doNose_

bool TrackstersProducer::doNose_

private

Definition at line 46 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 51 of file TrackstersProducer.cc.

Referenced by produce().

iterIndex_

ticl::Trackster::IterationIndex TrackstersProducer::iterIndex_

private

Definition at line 58 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

itername_

const std::string TrackstersProducer::itername_

private

Definition at line 57 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 55 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 54 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

myAlgo_

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

private

Definition at line 47 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

myAlgoHFNose_

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

private

Definition at line 48 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 52 of file TrackstersProducer.cc.

Referenced by produce().

seeding_regions_token_

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

private

Definition at line 56 of file TrackstersProducer.cc.

Referenced by produce().