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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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 > >
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 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"),
      myAlgo_(std::make_unique<PatternRecognitionbyCA<TICLLayerTiles>>(ps, cache)),
      myAlgoHFNose_(std::make_unique<PatternRecognitionbyCA<TICLLayerTilesHFNose>>(ps, cache)),
      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")) {
  if (doNose_) {
    layer_clusters_tiles_hfnose_token_ =
        consumes<TICLLayerTilesHFNose>(ps.getParameter<edm::InputTag>("layer_clusters_hfnose_tiles"));
  } else {
    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 doNose_, ticl::Trackster::EM, edm::ParameterSet::getParameter(), ticl::Trackster::HAD, iterIndex_, itername_, layer_clusters_tiles_hfnose_token_, layer_clusters_tiles_token_, ticl::Trackster::MIP, 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 116 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::vector<int>>("filter_on_categories", {0});
  desc.add<double>("pid_threshold", 0.);                    // make default such that no filtering is applied
  desc.add<double>("energy_em_over_total_threshold", -1.);  // make default such that no filtering is applied
  desc.add<double>("max_longitudinal_sigmaPCA", 9999);
  desc.add<int>("shower_start_max_layer", 9999);  // make default such that no filtering is applied
  desc.add<int>("algo_verbosity", 0);
  desc.add<double>("min_cos_theta", 0.915);
  desc.add<double>("root_doublet_max_distance_from_seed_squared", 9999);
  desc.add<double>("min_cos_pointing", -1.);
  desc.add<int>("skip_layers", 0);
  desc.add<int>("max_missing_layers_in_trackster", 9999);
  desc.add<double>("etaLimitIncreaseWindow", 2.1);
  desc.add<int>("min_layers_per_trackster", 10);
  desc.add<double>("max_delta_time", 3.);  //nsigma
  desc.add<bool>("out_in_dfs", true);
  desc.add<int>("max_out_in_hops", 10);
  desc.add<bool>("oneTracksterPerTrackSeed", false);
  desc.add<bool>("promoteEmptyRegionToTrackster", false);
  desc.add<std::string>("eid_graph_path", "RecoHGCal/TICL/data/tf_models/energy_id_v0.pb");
  desc.add<std::string>("eid_input_name", "input");
  desc.add<std::string>("eid_output_name_energy", "output/regressed_energy");
  desc.add<std::string>("eid_output_name_id", "output/id_probabilities");
  desc.add<std::string>("itername", "unknown");
  desc.add<double>("eid_min_cluster_energy", 1.);
  desc.add<int>("eid_n_layers", 50);
  desc.add<int>("eid_n_clusters", 10);
  descriptions.add("trackstersProducer", desc);
}

References edm::ConfigurationDescriptions::add(), 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 156 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().

myAlgoHFNose_

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

private

Definition at line 48 of file TrackstersProducer.cc.

Referenced by produce().

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().