Inheritance diagram for PFRecoTauChargedHadronProducer:

Public Types
typedef reco::tau::PFRecoTauChargedHadronBuilderPlugin	Builder

typedef reco::tau::PFRecoTauChargedHadronQualityPlugin	Ranker

Public Types inherited from edm::stream::EDProducer<>
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

Public Member Functions
	PFRecoTauChargedHadronProducer (const edm::ParameterSet &cfg)

template<typename T >
void	print (const T &chargedHadron)

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

	~PFRecoTauChargedHadronProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	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)

Private Types
typedef std::list< std::unique_ptr< reco::PFRecoTauChargedHadron > >	ChargedHadronList

typedef reco::tau::RecoTauLexicographicalRanking< RankerList, reco::PFRecoTauChargedHadron >	ChargedHadronPredicate

typedef Builder::return_type	ChargedHadronVector

typedef std::vector< std::unique_ptr< Ranker > >	RankerList

Private Attributes
std::vector< std::unique_ptr< Builder > >	builders_

edm::EDGetTokenT< reco::JetView >	Jets_token

double	maxJetAbsEta_

double	minJetPt_

std::string	moduleLabel_

std::unique_ptr< StringCutObjectSelector< reco::PFRecoTauChargedHadron > >	outputSelector_

std::unique_ptr< ChargedHadronPredicate >	predicate_

RankerList	rankers_

edm::InputTag	srcJets_

int	verbosity_

Detailed Description

Definition at line 53 of file PFRecoTauChargedHadronProducer.cc.

Member Typedef Documentation

◆ Builder

typedef reco::tau::PFRecoTauChargedHadronBuilderPlugin PFRecoTauChargedHadronProducer::Builder

Definition at line 55 of file PFRecoTauChargedHadronProducer.cc.

◆ ChargedHadronList

typedef std::list<std::unique_ptr<reco::PFRecoTauChargedHadron> > PFRecoTauChargedHadronProducer::ChargedHadronList

private

Definition at line 69 of file PFRecoTauChargedHadronProducer.cc.

◆ ChargedHadronPredicate

typedef reco::tau::RecoTauLexicographicalRanking<RankerList, reco::PFRecoTauChargedHadron> PFRecoTauChargedHadronProducer::ChargedHadronPredicate

private

Definition at line 71 of file PFRecoTauChargedHadronProducer.cc.

◆ ChargedHadronVector

typedef Builder::return_type PFRecoTauChargedHadronProducer::ChargedHadronVector

private

Definition at line 68 of file PFRecoTauChargedHadronProducer.cc.

◆ Ranker

typedef reco::tau::PFRecoTauChargedHadronQualityPlugin PFRecoTauChargedHadronProducer::Ranker

Definition at line 56 of file PFRecoTauChargedHadronProducer.cc.

◆ RankerList

typedef std::vector<std::unique_ptr<Ranker> > PFRecoTauChargedHadronProducer::RankerList

private

Definition at line 67 of file PFRecoTauChargedHadronProducer.cc.

Constructor & Destructor Documentation

◆ PFRecoTauChargedHadronProducer()

PFRecoTauChargedHadronProducer::PFRecoTauChargedHadronProducer ( const edm::ParameterSet & cfg )

explicit

Definition at line 94 of file PFRecoTauChargedHadronProducer.cc.

References edm::ParameterSet::addParameter(), builders_, looper::cfg, beamerCreator::create(), get, Jets_token, maxJetAbsEta_, minJetPt_, outputSelector_, predicate_, muonDTDigis_cfi::pset, rankers_, corrVsCorr::selection, srcJets_, AlCaHLTBitMon_QueryRunRegistry::string, and verbosity_.

     : moduleLabel_(cfg.getParameter<std::string>("@module_label")) {
   srcJets_ = cfg.getParameter<edm::InputTag>("jetSrc");
   Jets_token = consumes<reco::JetView>(srcJets_);
   minJetPt_ = cfg.getParameter<double>("minJetPt");
   maxJetAbsEta_ = cfg.getParameter<double>("maxJetAbsEta");
   verbosity_ = cfg.getParameter<int>("verbosity");
 
   // get set of ChargedHadron builder plugins
   edm::VParameterSet psets_builders = cfg.getParameter<edm::VParameterSet>("builders");
   for (edm::VParameterSet::const_iterator pset = psets_builders.begin(); pset != psets_builders.end(); ++pset) {
     std::string pluginType = pset->getParameter<std::string>("plugin");
     edm::ParameterSet pset_modified = (*pset);
     pset_modified.addParameter<int>("verbosity", verbosity_);
     builders_.emplace_back(
         PFRecoTauChargedHadronBuilderPluginFactory::get()->create(pluginType, pset_modified, consumesCollector()));
   }
 
   // get set of plugins for ranking ChargedHadrons in quality
   edm::VParameterSet psets_rankers = cfg.getParameter<edm::VParameterSet>("ranking");
   for (edm::VParameterSet::const_iterator pset = psets_rankers.begin(); pset != psets_rankers.end(); ++pset) {
     std::string pluginType = pset->getParameter<std::string>("plugin");
     edm::ParameterSet pset_modified = (*pset);
     pset_modified.addParameter<int>("verbosity", verbosity_);
     rankers_.emplace_back(PFRecoTauChargedHadronQualityPluginFactory::get()->create(pluginType, pset_modified));
   }
 
   // build the sorting predicate
   predicate_ = std::make_unique<ChargedHadronPredicate>(rankers_);
 
   // check if we want to apply a final output selection
   std::string selection = cfg.getParameter<std::string>("outputSelection");
   if (!selection.empty()) {
     outputSelector_ = std::make_unique<StringCutObjectSelector<reco::PFRecoTauChargedHadron>>(selection);
   }
 
   produces<reco::PFJetChargedHadronAssociation>();
 }

◆ ~PFRecoTauChargedHadronProducer()

PFRecoTauChargedHadronProducer::~PFRecoTauChargedHadronProducer ( )

inlineoverride

Definition at line 59 of file PFRecoTauChargedHadronProducer.cc.

59 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 319 of file PFRecoTauChargedHadronProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), submitPVResolutionJobs::desc, reco::tau::RecoTauQualityCuts::fillDescriptions(), HLT_2022v12_cff::InputTag, beam_dqm_sourceclient-live_cfg::qualityCuts, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                 {
   // ak4PFJetsRecoTauChargedHadrons
   edm::ParameterSetDescription desc;
   {
     edm::ParameterSetDescription desc_ranking;
     desc_ranking.add<std::string>("selectionPassFunction", "-pt");
     desc_ranking.add<double>("selectionFailValue", 1000.0);
     desc_ranking.add<std::string>("selection", "algoIs(\"kChargedPFCandidate\")");
     desc_ranking.add<std::string>("name", "ChargedPFCandidate");
     desc_ranking.add<std::string>("plugin", "PFRecoTauChargedHadronStringQuality");
 
     edm::ParameterSet pset_ranking;
     pset_ranking.addParameter<std::string>("selectionPassFunction", "-pt");
     pset_ranking.addParameter<double>("selectionFailValue", 1000.0);
     pset_ranking.addParameter<std::string>("selection", "algoIs(\"kChargedPFCandidate\")");
     pset_ranking.addParameter<std::string>("name", "ChargedPFCandidate");
     pset_ranking.addParameter<std::string>("plugin", "PFRecoTauChargedHadronStringQuality");
     std::vector<edm::ParameterSet> vpsd_ranking;
     vpsd_ranking.push_back(pset_ranking);
 
     desc.addVPSet("ranking", desc_ranking, vpsd_ranking);
   }
 
   desc.add<int>("verbosity", 0);
   desc.add<double>("maxJetAbsEta", 2.5);
   desc.add<std::string>("outputSelection", "pt > 0.5");
   desc.add<double>("minJetPt", 14.0);
   desc.add<edm::InputTag>("jetSrc", edm::InputTag("ak4PFJets"));
 
   {
     edm::ParameterSetDescription desc_builders;
     desc_builders.add<double>("minMergeChargedHadronPt");
     desc_builders.add<std::string>("name");
     desc_builders.add<std::string>("plugin");
     desc_builders.addOptional<double>("dRcone");
     desc_builders.addOptional<bool>("dRconeLimitedToJetArea");
     desc_builders.addOptional<double>("dRmergeNeutralHadron");
     desc_builders.addOptional<double>("dRmergePhoton");
     desc_builders.addOptional<edm::InputTag>("srcTracks");
 
     edm::ParameterSetDescription desc_qualityCuts;
     reco::tau::RecoTauQualityCuts::fillDescriptions(desc_qualityCuts);
     desc_builders.add<edm::ParameterSetDescription>("qualityCuts", desc_qualityCuts);
 
     desc_builders.add<double>("minMergeGammaEt");
     desc_builders.add<int>("verbosity", 0);
     desc_builders.add<double>("minMergeNeutralHadronEt");
 
     desc_builders.addOptional<double>("dRmergePhotonWrtChargedHadron");
     desc_builders.addOptional<double>("dRmergePhotonWrtNeutralHadron");
     desc_builders.addOptional<int>("maxUnmatchedBlockElementsNeutralHadron");
     desc_builders.addOptional<double>("dRmergePhotonWrtElectron");
     desc_builders.addOptional<std::vector<int>>("chargedHadronCandidatesParticleIds");
     desc_builders.addOptional<int>("minBlockElementMatchesPhoton");
     desc_builders.addOptional<double>("dRmergeNeutralHadronWrtNeutralHadron");
     desc_builders.addOptional<int>("maxUnmatchedBlockElementsPhoton");
     desc_builders.addOptional<double>("dRmergeNeutralHadronWrtOther");
     desc_builders.addOptional<double>("dRmergeNeutralHadronWrtElectron");
     desc_builders.addOptional<int>("minBlockElementMatchesNeutralHadron");
     desc_builders.addOptional<double>("dRmergePhotonWrtOther");
     desc_builders.addOptional<double>("dRmergeNeutralHadronWrtChargedHadron");
 
     edm::ParameterSet pset_builders;
     pset_builders.addParameter<std::string>("name", "");
     pset_builders.addParameter<std::string>("plugin", "");
     edm::ParameterSet qualityCuts;
     pset_builders.addParameter<edm::ParameterSet>("qualityCuts", qualityCuts);
     pset_builders.addParameter<int>("verbosity", 0);
     std::vector<edm::ParameterSet> vpsd_builders;
     vpsd_builders.push_back(pset_builders);
 
     desc.addVPSet("builders", desc_builders, vpsd_builders);
   }
 
   descriptions.add("pfRecoTauChargedHadronProducer", desc);
 }

◆ print()

template<typename T >

void PFRecoTauChargedHadronProducer::print ( const T & chargedHadron )

Definition at line 308 of file PFRecoTauChargedHadronProducer.cc.

References HPSPFTauProducerPuppi_cfi::chargedHadron, rankers_, and ApeEstimator_cff::width.

Referenced by produce().

                                                                  {
   edm::LogPrint("PFRecoTauChHProducer") << chargedHadron;
   edm::LogPrint("PFRecoTauChHProducer") << "Rankers:";
   for (auto const& ranker : rankers_) {
     constexpr unsigned width = 25;
     edm::LogPrint("PFRecoTauChHProducer")
         << " " << std::setiosflags(std::ios::left) << std::setw(width) << ranker->name() << " "
         << std::resetiosflags(std::ios::left) << std::setprecision(3) << (*ranker)(chargedHadron) << std::endl;
   }
 }

◆ produce()

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

override

Definition at line 133 of file PFRecoTauChargedHadronProducer.cc.

References a, funct::abs(), b, builders_, PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, MillePedeFileConverter_cfg::e, cppFunctionSkipper::exception, edm::Event::getByToken(), reco::tau::getTrackFromChargedHadron(), mps_fire::i, PDWG_EXODelayedJetMET_cff::jets, Jets_token, reco::PFRecoTauChargedHadron::kPFNeutralHadron, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, maxJetAbsEta_, minJetPt_, moduleLabel_, eostools::move(), outputSelector_, pfJetBenchmark_cfi::pfJets, predicate_, print(), edm::Event::put(), mps_fire::result, DBoxMetadataHelper::set_difference(), reco::tau::setChargedHadronP4(), HLT_2022v12_cff::track, and verbosity_.

                                                                                    {
   if (verbosity_) {
     edm::LogPrint("PFRecoTauChHProducer") << "<PFRecoTauChargedHadronProducer::produce>:";
     edm::LogPrint("PFRecoTauChHProducer") << " moduleLabel = " << moduleLabel_;
   }
 
   // give each of our plugins a chance at doing something with the edm::Event
   for (auto& builder : builders_) {
     builder->setup(evt, es);
   }
 
   // get a view of our jets via the base candidates
   edm::Handle<reco::JetView> jets;
   evt.getByToken(Jets_token, jets);
 
   // convert the view to a RefVector of actual PFJets
   edm::RefToBaseVector<reco::Jet> pfJets;
   size_t nElements = jets->size();
   for (size_t i = 0; i < nElements; ++i) {
     pfJets.push_back(jets->refAt(i));
   }
 
   // make our association
   std::unique_ptr<reco::PFJetChargedHadronAssociation> pfJetChargedHadronAssociations;
 
   if (!pfJets.empty()) {
     pfJetChargedHadronAssociations = std::make_unique<reco::PFJetChargedHadronAssociation>(reco::JetRefBaseProd(jets));
   } else {
     pfJetChargedHadronAssociations = std::make_unique<reco::PFJetChargedHadronAssociation>();
   }
 
   // loop over our jets
   for (const auto& pfJet : pfJets) {
     if (pfJet->pt() - minJetPt_ < 1e-5)
       continue;
     if (std::abs(pfJet->eta()) - maxJetAbsEta_ > -1e-5)
       continue;
 
     // build global list of ChargedHadron candidates for each jet
     ChargedHadronList uncleanedChargedHadrons;
 
     // merge candidates reconstructed by all desired algorithm plugins
     for (auto const& builder : builders_) {
       try {
         ChargedHadronVector result((*builder)(*pfJet));
         if (verbosity_) {
           edm::LogPrint("PFRecoTauChHProducer") << "result of builder = " << builder->name() << ":";
           for (auto const& had : result) {
             print(*had);
           }
         }
         std::move(result.begin(), result.end(), std::back_inserter(uncleanedChargedHadrons));
       } catch (cms::Exception& exception) {
         edm::LogError("BuilderPluginException")
             << "Exception caught in builder plugin " << builder->name() << ", rethrowing" << std::endl;
         throw exception;
       }
     }
 
     // rank the candidates according to our quality plugins
     uncleanedChargedHadrons.sort([this](const auto& a, const auto& b) { return (*predicate_)(*a, *b); });
 
     // define collection of cleaned ChargedHadrons;
     std::vector<reco::PFRecoTauChargedHadron> cleanedChargedHadrons;
 
     // keep track of neutral PFCandidates, charged PFCandidates and tracks "used" by ChargedHadron candidates in the clean collection
     typedef std::pair<double, double> etaPhiPair;
     std::list<etaPhiPair> tracksInCleanCollection;
     std::set<reco::CandidatePtr> neutralPFCandsInCleanCollection;
 
     while (!uncleanedChargedHadrons.empty()) {
       // get next best ChargedHadron candidate
       std::unique_ptr<reco::PFRecoTauChargedHadron> nextChargedHadron = std::move(uncleanedChargedHadrons.front());
       uncleanedChargedHadrons.pop_front();
       if (verbosity_) {
         edm::LogPrint("PFRecoTauChHProducer") << "processing nextChargedHadron:";
         edm::LogPrint("PFRecoTauChHProducer") << (*nextChargedHadron);
       }
 
       // discard candidates which fail final output selection
       if (!(*outputSelector_)(*nextChargedHadron))
         continue;
 
       const reco::Track* track = reco::tau::getTrackFromChargedHadron(*nextChargedHadron);
 
       // discard candidate in case its track is "used" by any ChargedHadron in the clean collection
       bool isTrack_overlap = false;
       if (track) {
         double track_eta = track->eta();
         double track_phi = track->phi();
         for (std::list<etaPhiPair>::const_iterator trackInCleanCollection = tracksInCleanCollection.begin();
              trackInCleanCollection != tracksInCleanCollection.end();
              ++trackInCleanCollection) {
           double dR = deltaR(track_eta, track_phi, trackInCleanCollection->first, trackInCleanCollection->second);
           if (dR < 1.e-4)
             isTrack_overlap = true;
         }
       }
       if (verbosity_) {
         edm::LogPrint("PFRecoTauChHProducer") << "isTrack_overlap = " << isTrack_overlap;
       }
       if (isTrack_overlap)
         continue;
 
       // discard ChargedHadron candidates without track in case they are close to neutral PFCandidates "used" by ChargedHadron candidates in the clean collection
       bool isNeutralPFCand_overlap = false;
       if (nextChargedHadron->algoIs(reco::PFRecoTauChargedHadron::kPFNeutralHadron)) {
         for (std::set<reco::CandidatePtr>::const_iterator neutralPFCandInCleanCollection =
                  neutralPFCandsInCleanCollection.begin();
              neutralPFCandInCleanCollection != neutralPFCandsInCleanCollection.end();
              ++neutralPFCandInCleanCollection) {
           if ((*neutralPFCandInCleanCollection) == nextChargedHadron->getChargedPFCandidate())
             isNeutralPFCand_overlap = true;
         }
       }
       if (verbosity_) {
         edm::LogPrint("PFRecoTauChHProducer") << "isNeutralPFCand_overlap = " << isNeutralPFCand_overlap;
       }
       if (isNeutralPFCand_overlap)
         continue;
 
       // find neutral PFCandidates that are not "used" by any ChargedHadron in the clean collection
       std::vector<reco::CandidatePtr> uniqueNeutralPFCands;
       std::set_difference(nextChargedHadron->getNeutralPFCandidates().begin(),
                           nextChargedHadron->getNeutralPFCandidates().end(),
                           neutralPFCandsInCleanCollection.begin(),
                           neutralPFCandsInCleanCollection.end(),
                           std::back_inserter(uniqueNeutralPFCands));
 
       if (uniqueNeutralPFCands.size() ==
           nextChargedHadron->getNeutralPFCandidates()
               .size()) {  // all neutral PFCandidates are unique, add ChargedHadron candidate to clean collection
         if (track)
           tracksInCleanCollection.push_back(std::make_pair(track->eta(), track->phi()));
         neutralPFCandsInCleanCollection.insert(nextChargedHadron->getNeutralPFCandidates().begin(),
                                                nextChargedHadron->getNeutralPFCandidates().end());
         if (verbosity_) {
           edm::LogPrint("PFRecoTauChHProducer") << "--> adding nextChargedHadron to output collection.";
         }
         cleanedChargedHadrons.push_back(*nextChargedHadron);
       } else {  // remove overlapping neutral PFCandidates, reevaluate ranking criterion and process ChargedHadron candidate again
         nextChargedHadron->neutralPFCandidates_.clear();
         for (auto const& neutralPFCand : uniqueNeutralPFCands) {
           nextChargedHadron->neutralPFCandidates_.push_back(neutralPFCand);
         }
         // update ChargedHadron four-momentum
         reco::tau::setChargedHadronP4(*nextChargedHadron);
         // reinsert ChargedHadron candidate into list of uncleaned candidates,
         // at position according to new rank
         auto insertionPoint = std::lower_bound(uncleanedChargedHadrons.begin(),
                                                uncleanedChargedHadrons.end(),
                                                *nextChargedHadron,
                                                [this](const auto& a, const auto& b) { return (*predicate_)(*a, b); });
         if (verbosity_) {
           edm::LogPrint("PFRecoTauChHProducer") << "--> removing non-unique neutral PFCandidates and reinserting "
                                                    "nextChargedHadron in uncleaned collection.";
         }
         uncleanedChargedHadrons.insert(insertionPoint, std::move(nextChargedHadron));
       }
     }
 
     if (verbosity_) {
       for (auto const& had : cleanedChargedHadrons) {
         print(had);
       }
     }
 
     // add ChargedHadron-to-jet association
     pfJetChargedHadronAssociations->setValue(pfJet.key(), cleanedChargedHadrons);
   }
 
   evt.put(std::move(pfJetChargedHadronAssociations));
 }