#include <TracksterLinkingbySuperClusteringMustache.h>

Inheritance diagram for ticl::TracksterLinkingbySuperClusteringMustache:

Public Member Functions
void	initialize (const HGCalDDDConstants *hgcons, const hgcal::RecHitTools rhtools, const edm::ESHandle< MagneticField > bfieldH, const edm::ESHandle< Propagator > propH) override

void	linkTracksters (const Inputs &input, std::vector< Trackster > &resultTracksters, std::vector< std::vector< unsigned int >> &linkedResultTracksters, std::vector< std::vector< unsigned int >> &linkedTracksterIdToInputTracksterId) override

virtual void	setEvent (edm::Event &iEvent, edm::EventSetup const &iEventSetup) override

	TracksterLinkingbySuperClusteringMustache (const edm::ParameterSet &ps, edm::ConsumesCollector iC, cms::Ort::ONNXRuntime const *onnxRuntime=nullptr)

	~TracksterLinkingbySuperClusteringMustache () override

Public Member Functions inherited from ticl::TracksterLinkingAlgoBase
	TracksterLinkingAlgoBase (const edm::ParameterSet &conf, edm::ConsumesCollector, cms::Ort::ONNXRuntime const *onnxRuntime=nullptr)

virtual	~TracksterLinkingAlgoBase ()

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &iDesc)

Static Public Member Functions inherited from ticl::TracksterLinkingAlgoBase
static void	fillPSetDescription (edm::ParameterSetDescription &desc)

Private Member Functions
bool	trackstersPassesPIDCut (const Trackster &ts) const

Private Attributes
float	candidateEnergyThreshold_

edm::ESGetToken< EcalMustacheSCParameters, EcalMustacheSCParametersRcd >	ecalMustacheSCParametersToken_

edm::ESGetToken< EcalSCDynamicDPhiParameters, EcalSCDynamicDPhiParametersRcd >	ecalSCDynamicDPhiParametersToken_

bool	filterByTracksterPID_

const EcalMustacheSCParameters *	mustacheSCParams_

float	PIDThreshold_

const EcalSCDynamicDPhiParameters *	scDynamicDPhiParams_

float	seedThresholdPt_

std::vector< int >	tracksterPIDCategoriesToFilter_

Additional Inherited Members
Protected Attributes inherited from ticl::TracksterLinkingAlgoBase
int	algo_verbosity_

cms::Ort::ONNXRuntime const *	onnxRuntime_

Detailed Description

Definition at line 29 of file TracksterLinkingbySuperClusteringMustache.h.

Constructor & Destructor Documentation

◆ TracksterLinkingbySuperClusteringMustache()

TracksterLinkingbySuperClusteringMustache::TracksterLinkingbySuperClusteringMustache	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector	iC,
		cms::Ort::ONNXRuntime const *	onnxRuntime = `nullptr`
	)

Definition at line 17 of file TracksterLinkingbySuperClusteringMustache.cc.

     : TracksterLinkingAlgoBase(ps, iC, onnxRuntime),
       ecalMustacheSCParametersToken_(iC.esConsumes<EcalMustacheSCParameters, EcalMustacheSCParametersRcd>()),
       ecalSCDynamicDPhiParametersToken_(iC.esConsumes<EcalSCDynamicDPhiParameters, EcalSCDynamicDPhiParametersRcd>()),
       seedThresholdPt_(ps.getParameter<double>("seedThresholdPt")),
       candidateEnergyThreshold_(ps.getParameter<double>("candidateEnergyThreshold")),
       filterByTracksterPID_(ps.getParameter<bool>("filterByTracksterPID")),
       tracksterPIDCategoriesToFilter_(ps.getParameter<std::vector<int>>("tracksterPIDCategoriesToFilter")),
       PIDThreshold_(ps.getParameter<double>("PIDThreshold")) {}

◆ ~TracksterLinkingbySuperClusteringMustache()

ticl::TracksterLinkingbySuperClusteringMustache::~TracksterLinkingbySuperClusteringMustache ( )

inlineoverride

Definition at line 34 of file TracksterLinkingbySuperClusteringMustache.h.

34 {}

Member Function Documentation

◆ fillPSetDescription()

void TracksterLinkingbySuperClusteringMustache::fillPSetDescription ( edm::ParameterSetDescription & iDesc )

static

Definition at line 124 of file TracksterLinkingbySuperClusteringMustache.cc.

References submitPVResolutionJobs::desc, ticl::Trackster::electron, ticl::TracksterLinkingAlgoBase::fillPSetDescription(), and ticl::Trackster::photon.

                                                                                                     {
   TracksterLinkingAlgoBase::fillPSetDescription(desc);  // adds algo_verbosity
   desc.add<double>("seedThresholdPt", 1.)
       ->setComment("Minimum transverse energy of trackster to be considered as seed of a supercluster");
   desc.add<double>("candidateEnergyThreshold", 0.15)
       ->setComment("Minimum energy of trackster to be considered as candidate for superclustering");
   desc.add<bool>("filterByTracksterPID", true)->setComment("Filter tracksters before superclustering by PID score");
   desc.add<std::vector<int>>(
           "tracksterPIDCategoriesToFilter",
           {static_cast<int>(Trackster::ParticleType::photon), static_cast<int>(Trackster::ParticleType::electron)})
       ->setComment("List of PID particle types (ticl::Trackster::ParticleType enum) to consider for PID filtering");
   desc.add<double>("PIDThreshold", 0.8)->setComment("PID score threshold");
 }

◆ initialize()

void TracksterLinkingbySuperClusteringMustache::initialize	(	const HGCalDDDConstants *	hgcons,
		const hgcal::RecHitTools	rhtools,
		const edm::ESHandle< MagneticField >	bfieldH,
		const edm::ESHandle< Propagator >	propH
	)

overridevirtual

Implements ticl::TracksterLinkingAlgoBase.

Definition at line 28 of file TracksterLinkingbySuperClusteringMustache.cc.

31 {}

◆ linkTracksters()

void TracksterLinkingbySuperClusteringMustache::linkTracksters	(	const Inputs &	input,
		std::vector< Trackster > &	resultTracksters,
		std::vector< std::vector< unsigned int >> &	outputSuperclusters,
		std::vector< std::vector< unsigned int >> &	linkedTracksterIdToInputTracksterId
	)

overridevirtual

resultTracksters : superclusters as tracksters (ie merging of tracksters that have been superclustered together) outputSuperclusters : same as linkedTracksterIdToInputTracksterId. Probably should use only one of the two. linkedTracksterIdToInputTracksterId : maps indices from resultTracksters back into input tracksters. resultTracksters[i] has seed input.tracksters[linkedTracksterIdToInputTracksterId[i][0]], linked with tracksters input.tracksters[linkedTracksterIdToInputTracksterId[i][1..N]]

Implements ticl::TracksterLinkingAlgoBase.

Definition at line 55 of file TracksterLinkingbySuperClusteringMustache.cc.

References ticl::Trackster::barycenter(), candidateEnergyThreshold_, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, reco::MustacheKernel::inDynamicDPhiWindow(), reco::MustacheKernel::inMustache(), input, mustacheSCParams_, ticl::Trackster::raw_energy(), ticl::Trackster::raw_pt(), scDynamicDPhiParams_, seedThresholdPt_, and trackstersPassesPIDCut().

                                                                              {
   // For now we use all input tracksters for superclustering. At some point there might be a filter here for EM tracksters (electromagnetic identification with DNN ?)
   auto const& inputTracksters = input.tracksters;
   const unsigned int tracksterCount = inputTracksters.size();
 
   /* Sorting tracksters by decreasing order of pT (out-of-place sort). 
   inputTracksters[trackstersIndicesPt[0]], ..., inputTracksters[trackstersIndicesPt[N]] makes a list of tracksters sorted by decreasing pT
   Indices into this pT sorted collection will have the suffix _pt. Thus inputTracksters[index] and inputTracksters[trackstersIndicesPt[index_pt]] are correct
   */
   std::vector<unsigned int> trackstersIndicesPt(inputTracksters.size());
   std::iota(trackstersIndicesPt.begin(), trackstersIndicesPt.end(), 0);
   std::stable_sort(
       trackstersIndicesPt.begin(), trackstersIndicesPt.end(), [&inputTracksters](unsigned int i1, unsigned int i2) {
         return inputTracksters[i1].raw_pt() > inputTracksters[i2].raw_pt();
       });
 
   std::vector<bool> tracksterMask_pt(tracksterCount, false);  // Mask for already superclustered tracksters
   // We also mask tracksters that don't pass the PID cut
   for (unsigned int ts_idx_pt = 0; ts_idx_pt < tracksterCount; ts_idx_pt++) {
     tracksterMask_pt[ts_idx_pt] = !trackstersPassesPIDCut(inputTracksters[trackstersIndicesPt[ts_idx_pt]]);
   }
 
   for (unsigned int ts_seed_idx_pt = 0; ts_seed_idx_pt < tracksterCount; ts_seed_idx_pt++) {
     Trackster const& ts_seed = inputTracksters[trackstersIndicesPt[ts_seed_idx_pt]];
     if (ts_seed.raw_pt() <= seedThresholdPt_)
       break;  // Look only at seed tracksters passing threshold, take advantage of pt sorting for fast exit
     if (tracksterMask_pt[ts_seed_idx_pt])
       continue;  // Trackster does not pass PID cut
 
     outputSuperclusters.emplace_back(std::initializer_list<unsigned int>{trackstersIndicesPt[ts_seed_idx_pt]});
     resultTracksters.emplace_back(inputTracksters[trackstersIndicesPt[ts_seed_idx_pt]]);
     linkedTracksterIdToInputTracksterId.emplace_back(
         std::initializer_list<unsigned int>{trackstersIndicesPt[ts_seed_idx_pt]});
 
     for (unsigned int ts_cand_idx_pt = ts_seed_idx_pt + 1; ts_cand_idx_pt < tracksterCount; ts_cand_idx_pt++) {
       if (tracksterMask_pt[ts_cand_idx_pt])
         continue;  // Trackster is either already superclustered or did not pass PID cut
 
       Trackster const& ts_cand = inputTracksters[trackstersIndicesPt[ts_cand_idx_pt]];
 
       if (ts_cand.raw_energy() <= candidateEnergyThreshold_)
         continue;
 
       const bool passes_dphi = reco::MustacheKernel::inDynamicDPhiWindow(scDynamicDPhiParams_,
                                                                          ts_seed.barycenter().eta(),
                                                                          ts_seed.barycenter().phi(),
                                                                          ts_cand.raw_energy(),
                                                                          ts_cand.barycenter().eta(),
                                                                          ts_cand.barycenter().phi());
 
       if (passes_dphi && reco::MustacheKernel::inMustache(mustacheSCParams_,
                                                           ts_seed.barycenter().eta(),
                                                           ts_seed.barycenter().phi(),
                                                           ts_cand.raw_energy(),
                                                           ts_cand.barycenter().eta(),
                                                           ts_cand.barycenter().phi())) {
         outputSuperclusters.back().push_back(trackstersIndicesPt[ts_cand_idx_pt]);
         resultTracksters.back().mergeTracksters(ts_cand);
         linkedTracksterIdToInputTracksterId.back().push_back(trackstersIndicesPt[ts_cand_idx_pt]);
         tracksterMask_pt[ts_cand_idx_pt] = true;
       }
     }
   }
 }

◆ setEvent()

void TracksterLinkingbySuperClusteringMustache::setEvent	(	edm::Event &	iEvent,
		edm::EventSetup const &	iEventSetup
	)

overridevirtual

Reimplemented from ticl::TracksterLinkingAlgoBase.

Definition at line 33 of file TracksterLinkingbySuperClusteringMustache.cc.

References ecalMustacheSCParametersToken_, ecalSCDynamicDPhiParametersToken_, edm::EventSetup::getData(), mustacheSCParams_, and scDynamicDPhiParams_.

                                                                                                            {
   mustacheSCParams_ = &iEventSetup.getData(ecalMustacheSCParametersToken_);
   scDynamicDPhiParams_ = &iEventSetup.getData(ecalSCDynamicDPhiParametersToken_);
 }

◆ trackstersPassesPIDCut()

bool TracksterLinkingbySuperClusteringMustache::trackstersPassesPIDCut ( const Trackster & ts ) const

private

Definition at line 38 of file TracksterLinkingbySuperClusteringMustache.cc.

References eostools::cat(), filterByTracksterPID_, ticl::Trackster::id_probabilities(), PIDThreshold_, and tracksterPIDCategoriesToFilter_.

Referenced by linkTracksters().

                                                                                                  {
   if (filterByTracksterPID_) {
     float probTotal = 0.0f;
     for (int cat : tracksterPIDCategoriesToFilter_) {
       probTotal += tst.id_probabilities(cat);
     }
     return probTotal >= PIDThreshold_;
   } else
     return true;
 }