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	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () 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
edm::EDGetTokenT< std::vector< reco::CaloCluster > >	clusters_token_

edm::EDGetTokenT< edm::ValueMap< float > >	clustersTime_token_

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

edm::EDGetTokenT< TICLLayerTiles >	layer_clusters_tiles_token_

std::unique_ptr< PatternRecognitionAlgoBase >	myAlgo_

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

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

explicit

Definition at line 75 of file TrackstersProducer.cc.

References clusters_token_, clustersTime_token_, filtered_layerclusters_mask_token_, edm::ParameterSet::getParameter(), layer_clusters_tiles_token_, original_layerclusters_mask_token_, and seeding_regions_token_.

     : myAlgo_(std::make_unique<PatternRecognitionbyCA>(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<float>>(ps.getParameter<edm::InputTag>("time_layerclusters"));
   layer_clusters_tiles_token_ = consumes<TICLLayerTiles>(ps.getParameter<edm::InputTag>("layer_clusters_tiles"));
   seeding_regions_token_ = consumes<std::vector<TICLSeedingRegion>>(ps.getParameter<edm::InputTag>("seeding_regions"));
 
   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.

References fillDescriptions().

35 {}

Member Function Documentation

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

static

Definition at line 88 of file TrackstersProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                     {
   // hgcalMultiClusters
   edm::ParameterSetDescription desc;
   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>("seeding_regions", edm::InputTag("ticlSeedingRegionProducer"));
   desc.add<int>("algo_verbosity", 0);
   desc.add<double>("min_cos_theta", 0.915);
   desc.add<double>("min_cos_pointing", -1.);
   desc.add<int>("missing_layers", 0);
   desc.add<int>("min_clusters_per_ntuplet", 10);
   desc.add<double>("max_delta_time", 0.09);
   desc.add<bool>("out_in_dfs", true);
   desc.add<int>("max_out_in_hops", 10);
   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<double>("eid_min_cluster_energy", 1.);
   desc.add<int>("eid_n_layers", 50);
   desc.add<int>("eid_n_clusters", 10);
   descriptions.add("trackstersProducer", desc);
 }

void TrackstersProducer::globalEndJob ( TrackstersCache * cache )

static

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

References utilities::cache(), edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), tensorflow::loadGraphDef(), CalibrationSummaryClient_cfi::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 115 of file TrackstersProducer.cc.

References begin, clusters_token_, clustersTime_token_, filterCSVwithJSON::copy, end, filtered_layerclusters_mask_token_, edm::Event::getByToken(), input, layer_clusters_tiles_token_, eostools::move(), myAlgo_, 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>>();
 
   edm::Handle<std::vector<reco::CaloCluster>> cluster_h;
   edm::Handle<std::vector<float>> filtered_layerclusters_mask_h;
   edm::Handle<std::vector<float>> original_layerclusters_mask_h;
   edm::Handle<edm::ValueMap<float>> time_clusters_h;
   edm::Handle<TICLLayerTiles> layer_clusters_tiles_h;
   edm::Handle<std::vector<TICLSeedingRegion>> seeding_regions_h;
 
   evt.getByToken(clusters_token_, cluster_h);
   evt.getByToken(filtered_layerclusters_mask_token_, filtered_layerclusters_mask_h);
   evt.getByToken(original_layerclusters_mask_token_, original_layerclusters_mask_h);
   evt.getByToken(clustersTime_token_, time_clusters_h);
   evt.getByToken(layer_clusters_tiles_token_, layer_clusters_tiles_h);
   evt.getByToken(seeding_regions_token_, seeding_regions_h);
 
   const auto& layerClusters = *cluster_h;
   const auto& inputClusterMask = *filtered_layerclusters_mask_h;
   const auto& layerClustersTimes = *time_clusters_h;
   const auto& layer_clusters_tiles = *layer_clusters_tiles_h;
   const auto& seeding_regions = *seeding_regions_h;
   const ticl::PatternRecognitionAlgoBase::Inputs input(
       evt, es, layerClusters, inputClusterMask, layerClustersTimes, layer_clusters_tiles, seeding_regions);
   myAlgo_->makeTracksters(input, *result);
 
   // Now update the global mask and put it into the event
   output_mask->reserve(original_layerclusters_mask_h->size());
   // Copy over the previous state
   std::copy(std::begin(*original_layerclusters_mask_h),
             std::end(*original_layerclusters_mask_h),
             std::back_inserter(*output_mask));
   // Mask the used elements, accordingly
   for (auto const& trackster : *result) {
     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));
 }