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_ = 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< 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 ( const edm::ParameterSet &  ps, const TrackstersCache *  cache  )

explicit

Definition at line 81 of file TrackstersProducer.cc.

References 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.

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

TrackstersProducer::~TrackstersProducer ( )

inlineoverride

Definition at line 35 of file TrackstersProducer.cc.

{}

Member Function Documentation

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

static

Definition at line 120 of file TrackstersProducer.cc.

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

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

void TrackstersProducer::globalEndJob ( TrackstersCache *  cache )

static

Definition at line 76 of file TrackstersProducer.cc.

References ticl::TrackstersCache::eidGraphDef.

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

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

static

Definition at line 62 of file TrackstersProducer.cc.

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

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

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

override

Definition at line 148 of file TrackstersProducer.cc.

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

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

Member Data Documentation

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

private

Definition at line 50 of file TrackstersProducer.cc.

Referenced by produce().

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

private

Definition at line 53 of file TrackstersProducer.cc.

Referenced by produce().

std::string TrackstersProducer::detector_

private

Definition at line 45 of file TrackstersProducer.cc.

bool TrackstersProducer::doNose_

private

Definition at line 46 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

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

private

Definition at line 51 of file TrackstersProducer.cc.

Referenced by produce().

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

private

Definition at line 58 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

const std::string TrackstersProducer::itername_

private

Definition at line 57 of file TrackstersProducer.cc.

Referenced by TrackstersProducer().

edm::EDGetTokenT<TICLLayerTilesHFNose> TrackstersProducer::layer_clusters_tiles_hfnose_token_

private

Definition at line 55 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

edm::EDGetTokenT<TICLLayerTiles> TrackstersProducer::layer_clusters_tiles_token_

private

Definition at line 54 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

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

private

Definition at line 47 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

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

private

Definition at line 48 of file TrackstersProducer.cc.

Referenced by produce(), and TrackstersProducer().

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

private

Definition at line 52 of file TrackstersProducer.cc.

Referenced by produce().

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

private

Definition at line 56 of file TrackstersProducer.cc.

Referenced by produce().