Inheritance diagram for SuperclusteringSampleDumper:

Public Member Functions
	SuperclusteringSampleDumper (const edm::ParameterSet &)

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const noexcept

bool	wantsStreamRuns () const noexcept

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	beginJob () override

bool	checkExplainedVarianceRatioCut (ticl::Trackster const &ts) const

Private Attributes
float	candidateEnergyThreshold_

std::vector< float >	candidateTracksterAssociationWithSeed_score_

std::vector< long >	candidateTracksterBestAssociation_simTsIdx_

std::vector< float >	candidateTracksterBestAssociationScore_

std::vector< unsigned int >	candidateTracksterIdx_

float	deltaEtaWindow_

float	deltaPhiWindow_

std::unique_ptr< AbstractSuperclusteringDNNInput >	dnnInput_

edm::EventID	eventId_

float	explVarRatioCut_energyBoundary_

float	explVarRatioMinimum_highEnergy_

float	explVarRatioMinimum_lowEnergy_

std::vector< std::vector< float > >	features_

TTree *	output_tree_

float	seedPtThreshold_

std::vector< float >	seedTracksterBestAssociation_caloParticleEnergy_

std::vector< long >	seedTracksterBestAssociation_simTsIdx_

std::vector< float >	seedTracksterBestAssociationScore_

std::vector< unsigned int >	seedTracksterIdx_

const edm::EDGetTokenT< std::vector< Trackster > >	tracksters_clue3d_token_

const edm::EDGetTokenT< ticl::RecoToSimCollectionSimTracksters >	tsRecoToSimCP_token_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 39 of file SuperclusteringSampleDumper.cc.

Constructor & Destructor Documentation

◆ SuperclusteringSampleDumper()

SuperclusteringSampleDumper::SuperclusteringSampleDumper ( const edm::ParameterSet & ps )

explicit

Definition at line 83 of file SuperclusteringSampleDumper.cc.

     : tracksters_clue3d_token_(consumes<std::vector<Trackster>>(ps.getParameter<edm::InputTag>("tracksters"))),
       tsRecoToSimCP_token_(
           consumes<ticl::RecoToSimCollectionSimTracksters>(ps.getParameter<edm::InputTag>("recoToSimAssociatorCP"))),
       deltaEtaWindow_(ps.getParameter<double>("deltaEtaWindow")),
       deltaPhiWindow_(ps.getParameter<double>("deltaPhiWindow")),
       seedPtThreshold_(ps.getParameter<double>("seedPtThreshold")),
       candidateEnergyThreshold_(ps.getParameter<double>("candidateEnergyThreshold")),
       explVarRatioCut_energyBoundary_(ps.getParameter<double>("candidateEnergyThreshold")),
       explVarRatioMinimum_lowEnergy_(ps.getParameter<double>("explVarRatioMinimum_lowEnergy")),
       explVarRatioMinimum_highEnergy_(ps.getParameter<double>("explVarRatioMinimum_highEnergy")),
       eventId_(),
       dnnInput_(makeSuperclusteringDNNInputFromString(ps.getParameter<std::string>("dnnInputsVersion"))),
       features_(dnnInput_->featureCount()) {
   usesResource("TFileService");
 }

Member Function Documentation

◆ analyze()

void SuperclusteringSampleDumper::analyze	(	const edm::Event &	evt,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 137 of file SuperclusteringSampleDumper.cc.

References funct::abs(), cms::cuda::assert(), trackingPlots::assoc, ticl::Trackster::barycenter(), candidateEnergyThreshold_, candidateTracksterAssociationWithSeed_score_, candidateTracksterBestAssociation_simTsIdx_, candidateTracksterBestAssociationScore_, candidateTracksterIdx_, checkExplainedVarianceRatioCut(), deltaEtaWindow_, SiPixelRawToDigiRegional_cfi::deltaPhi, deltaPhiWindow_, dnnInput_, edm::AssociationMap< Tag >::end(), eventId_, lowptgsfeleseed::features(), features_, edm::AssociationMap< Tag >::find(), edm::Event::getByToken(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, edm::EventBase::id(), output_tree_, ticl::Trackster::raw_energy(), ticl::Trackster::raw_pt(), seedPtThreshold_, seedTracksterBestAssociation_caloParticleEnergy_, seedTracksterBestAssociation_simTsIdx_, seedTracksterBestAssociationScore_, seedTracksterIdx_, tracksters_clue3d_token_, and tsRecoToSimCP_token_.

                                                                                           {
   eventId_ = evt.id();
 
   edm::Handle<std::vector<Trackster>> inputTracksters;
   evt.getByToken(tracksters_clue3d_token_, inputTracksters);
 
   edm::Handle<ticl::RecoToSimCollectionSimTracksters> assoc_CP_recoToSim;
   evt.getByToken(tsRecoToSimCP_token_, assoc_CP_recoToSim);
 
   /* 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();
       });
 
   // Order of loops are reversed compared to SuperclusteringProducer (here outer is seed, inner is candidate), for performance reasons.
   // The same pairs seed-candidate should be present, just in a different order
   // First loop on seed tracksters
   for (unsigned int ts_seed_idx_pt = 0; ts_seed_idx_pt < inputTracksters->size(); ts_seed_idx_pt++) {
     const unsigned int ts_seed_idx_input =
         trackstersIndicesPt[ts_seed_idx_pt];  // Index of seed trackster in input collection (not in pT sorted collection)
     Trackster const& ts_seed = (*inputTracksters)[ts_seed_idx_input];
 
     if (ts_seed.raw_pt() < seedPtThreshold_)
       break;  // All further seeds will have lower pT than threshold (due to pT sorting)
 
     if (!checkExplainedVarianceRatioCut(ts_seed))
       continue;
 
     // Find best associated CaloParticle to the seed
     auto seed_assocs = assoc_CP_recoToSim->find({inputTracksters, ts_seed_idx_input});
     if (seed_assocs == assoc_CP_recoToSim->end())
       continue;  // No CaloParticle associations for the current trackster (extremly unlikely)
     ticl::RecoToSimCollectionSimTracksters::data_type const& seed_assocWithBestScore =
         *std::min_element(seed_assocs->val.begin(),
                           seed_assocs->val.end(),
                           [](ticl::RecoToSimCollectionSimTracksters::data_type const& assoc_1,
                              ticl::RecoToSimCollectionSimTracksters::data_type const& assoc_2) {
                             // assoc_* is of type : std::pair<edmRefIntoSimTracksterCollection, std::pair<sharedEnergy, associationScore>>
                             // Best score is smallest score
                             return assoc_1.second.second < assoc_2.second.second;
                           });
 
     // Second loop on superclustering candidates tracksters
     // Look only at candidate tracksters with lower pT than the seed (so all pairs are only looked at once)
     for (unsigned int ts_cand_idx_pt = ts_seed_idx_pt + 1; ts_cand_idx_pt < inputTracksters->size(); ts_cand_idx_pt++) {
       Trackster const& ts_cand = (*inputTracksters)[trackstersIndicesPt[ts_cand_idx_pt]];
       // Check that the two tracksters are geometrically compatible for superclustering (using deltaEta, deltaPhi window)
       // There is no need to run training or inference for tracksters very far apart
       if (!(std::abs(ts_seed.barycenter().Eta() - ts_cand.barycenter().Eta()) < deltaEtaWindow_ &&
             std::abs(deltaPhi(ts_seed.barycenter().Phi(), ts_cand.barycenter().Phi())) < deltaPhiWindow_ &&
             ts_cand.raw_energy() >= candidateEnergyThreshold_ && checkExplainedVarianceRatioCut(ts_cand)))
         continue;
 
       std::vector<float> features = dnnInput_->computeVector(ts_seed, ts_cand);
       assert(features.size() == features_.size());
       for (unsigned int feature_idx = 0; feature_idx < features_.size(); feature_idx++) {
         features_[feature_idx].push_back(features[feature_idx]);
       }
       seedTracksterIdx_.push_back(trackstersIndicesPt[ts_seed_idx_pt]);
       candidateTracksterIdx_.push_back(trackstersIndicesPt[ts_cand_idx_pt]);
 
       float candidateTracksterBestAssociationScore = 1.;  // Best association score of candidate with any CaloParticle
       long candidateTracksterBestAssociation_simTsIdx = -1;  // Corresponding CaloParticle simTrackster index
       float candidateTracksterAssociationWithSeed_score =
           1.;  // Association score of candidate with CaloParticle best associated with seed
 
       // First find associated CaloParticles with candidate
       auto cand_assocCP = assoc_CP_recoToSim->find(
           edm::Ref<ticl::TracksterCollection>(inputTracksters, trackstersIndicesPt[ts_cand_idx_pt]));
       if (cand_assocCP != assoc_CP_recoToSim->end()) {
         // find the association with best score
         ticl::RecoToSimCollectionSimTracksters::data_type const& cand_assocWithBestScore =
             *std::min_element(cand_assocCP->val.begin(),
                               cand_assocCP->val.end(),
                               [](ticl::RecoToSimCollectionSimTracksters::data_type const& assoc_1,
                                  ticl::RecoToSimCollectionSimTracksters::data_type const& assoc_2) {
                                 // assoc_* is of type : std::pair<edmRefIntoSimTracksterCollection, std::pair<sharedEnergy, associationScore>>
                                 return assoc_1.second.second < assoc_2.second.second;
                               });
         candidateTracksterBestAssociationScore = cand_assocWithBestScore.second.second;
         candidateTracksterBestAssociation_simTsIdx = cand_assocWithBestScore.first.key();
 
         // find the association score with the same CaloParticle as the seed
         auto cand_assocWithSeedCP =
             std::find_if(cand_assocCP->val.begin(),
                          cand_assocCP->val.end(),
                          [&seed_assocWithBestScore](ticl::RecoToSimCollectionSimTracksters::data_type const& assoc) {
                            // assoc is of type : std::pair<edmRefIntoSimTracksterCollection, std::pair<sharedEnergy, associationScore>>
                            return assoc.first == seed_assocWithBestScore.first;
                          });
         if (cand_assocWithSeedCP != cand_assocCP->val.end()) {
           candidateTracksterAssociationWithSeed_score = cand_assocWithSeedCP->second.second;
         }
       }
 
       seedTracksterBestAssociationScore_.push_back(seed_assocWithBestScore.second.second);
       seedTracksterBestAssociation_simTsIdx_.push_back(seed_assocWithBestScore.first.key());
       seedTracksterBestAssociation_caloParticleEnergy_.push_back(seed_assocWithBestScore.first->regressed_energy());
 
       candidateTracksterBestAssociationScore_.push_back(candidateTracksterBestAssociationScore);
       candidateTracksterBestAssociation_simTsIdx_.push_back(candidateTracksterBestAssociation_simTsIdx);
 
       candidateTracksterAssociationWithSeed_score_.push_back(candidateTracksterAssociationWithSeed_score);
     }
   }
 
   output_tree_->Fill();
   for (auto& feats : features_)
     feats.clear();
   seedTracksterIdx_.clear();
   candidateTracksterIdx_.clear();
   seedTracksterBestAssociationScore_.clear();
   seedTracksterBestAssociation_simTsIdx_.clear();
   seedTracksterBestAssociation_caloParticleEnergy_.clear();
   candidateTracksterBestAssociationScore_.clear();
   candidateTracksterBestAssociation_simTsIdx_.clear();
   candidateTracksterAssociationWithSeed_score_.clear();
 }

◆ beginJob()

void SuperclusteringSampleDumper::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 100 of file SuperclusteringSampleDumper.cc.

References cms::cuda::assert(), candidateTracksterAssociationWithSeed_score_, candidateTracksterBestAssociation_simTsIdx_, candidateTracksterBestAssociationScore_, candidateTracksterIdx_, dnnInput_, eventId_, TrackQualityParams_cfi::featureNames, features_, compareTotals::fs, mps_fire::i, output_tree_, seedTracksterBestAssociation_caloParticleEnergy_, seedTracksterBestAssociation_simTsIdx_, seedTracksterBestAssociationScore_, and seedTracksterIdx_.

                                            {
   edm::Service<TFileService> fs;
   output_tree_ = fs->make<TTree>("superclusteringTraining", "Superclustering training samples");
   output_tree_->Branch("Event", &eventId_);
   output_tree_->Branch("seedTracksterIdx", &seedTracksterIdx_);
   output_tree_->Branch("candidateTracksterIdx", &candidateTracksterIdx_);
   output_tree_->Branch("seedTracksterBestAssociationScore", &seedTracksterBestAssociationScore_);
   output_tree_->Branch("seedTracksterBestAssociation_simTsIdx", &seedTracksterBestAssociation_simTsIdx_);
   output_tree_->Branch("seedTracksterBestAssociation_caloParticleEnergy",
                        &seedTracksterBestAssociation_caloParticleEnergy_);
   output_tree_->Branch("candidateTracksterBestAssociationScore", &candidateTracksterBestAssociationScore_);
   output_tree_->Branch("candidateTracksterBestAssociation_simTsIdx", &candidateTracksterBestAssociation_simTsIdx_);
   output_tree_->Branch("candidateTracksterAssociationWithSeed_score", &candidateTracksterAssociationWithSeed_score_);
   std::vector<std::string> featureNames = dnnInput_->featureNames();
   assert(featureNames.size() == dnnInput_->featureCount());
   for (unsigned int i = 0; i < dnnInput_->featureCount(); i++) {
     output_tree_->Branch(("feature_" + featureNames[i]).c_str(), &features_[i]);
   }
 }

◆ checkExplainedVarianceRatioCut()

bool SuperclusteringSampleDumper::checkExplainedVarianceRatioCut ( ticl::Trackster const & ts ) const

private

Check if trackster passes cut on explained variance ratio. The DNN is trained only on pairs where both seed and candidate pass this cut Explained variance ratio is (largest PCA eigenvalue) / (sum of PCA eigenvalues)

Definition at line 124 of file SuperclusteringSampleDumper.cc.

References ticl::Trackster::eigenvalues(), explVarRatioCut_energyBoundary_, explVarRatioMinimum_highEnergy_, explVarRatioMinimum_lowEnergy_, f, and ticl::Trackster::raw_energy().

Referenced by analyze().

                                                                                               {
   float explVar_denominator =
       std::accumulate(std::begin(ts.eigenvalues()), std::end(ts.eigenvalues()), 0.f, std::plus<float>());
   if (explVar_denominator != 0.) {
     float explVarRatio = ts.eigenvalues()[0] / explVar_denominator;
     if (ts.raw_energy() > explVarRatioCut_energyBoundary_)
       return explVarRatio >= explVarRatioMinimum_highEnergy_;
     else
       return explVarRatio >= explVarRatioMinimum_lowEnergy_;
   } else
     return false;
 }

◆ fillDescriptions()

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

static

Definition at line 262 of file SuperclusteringSampleDumper.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("tracksters", edm::InputTag("ticlTrackstersCLUE3DHigh"))
       ->setComment("Input trackster collection, same as what is used for superclustering inference.");
   desc.add<edm::InputTag>("recoToSimAssociatorCP",
                           edm::InputTag("tracksterSimTracksterAssociationLinkingbyCLUE3D", "recoToSim"));
   desc.ifValue(edm::ParameterDescription<std::string>("dnnInputsVersion", "v2", true),
                edm::allowedValues<std::string>("v1", "v2"))
       ->setComment(
           "DNN inputs version tag. Defines which set of features is fed to the DNN. Must match with the actual DNN.");
   // Cuts are intentionally looser than those used for inference in TracksterLinkingBySuperClustering.cpp
   desc.add<double>("deltaEtaWindow", 0.2)
       ->setComment(
           "Size of delta eta window to consider for superclustering. Seed-candidate pairs outside this window "
           "are not considered for DNN inference.");
   desc.add<double>("deltaPhiWindow", 0.7)
       ->setComment(
           "Size of delta phi window to consider for superclustering. Seed-candidate pairs outside this window "
           "are not considered for DNN inference.");
   desc.add<double>("seedPtThreshold", 3.)
       ->setComment("Minimum transverse momentum of trackster to be considered as seed of a supercluster");
   desc.add<double>("candidateEnergyThreshold", 1.5)
       ->setComment("Minimum energy of trackster to be considered as candidate for superclustering");
   desc.add<double>("explVarRatioCut_energyBoundary", 50.)
       ->setComment("Boundary energy between low and high energy explVarRatio cut threshold");
   desc.add<double>("explVarRatioMinimum_lowEnergy", 0.85)
       ->setComment(
           "Cut on explained variance ratio of tracksters to be considered as candidate, "
           "for trackster raw_energy < explVarRatioCut_energyBoundary");
   desc.add<double>("explVarRatioMinimum_highEnergy", 0.9)
       ->setComment(
           "Cut on explained variance ratio of tracksters to be considered as candidate, "
           "for trackster raw_energy > explVarRatioCut_energyBoundary");
   descriptions.add("superclusteringSampleDumper", desc);
 }