Inheritance diagram for PFRecoTauChargedHadronProducer:

Public Types
typedef reco::tau::PFRecoTauChargedHadronBuilderPlugin	Builder

typedef reco::tau::PFRecoTauChargedHadronQualityPlugin	Ranker

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

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

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

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

	~PFRecoTauChargedHadronProducer () override

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

Private Types
typedef boost::ptr_vector< Builder >	builderList

typedef boost::ptr_list< reco::PFRecoTauChargedHadron >	ChargedHadronList

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

typedef boost::ptr_vector< reco::PFRecoTauChargedHadron >	ChargedHadronVector

typedef boost::ptr_vector< Ranker >	rankerList

Private Attributes
builderList	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 54 of file PFRecoTauChargedHadronProducer.cc.

Member Typedef Documentation

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

Definition at line 56 of file PFRecoTauChargedHadronProducer.cc.

typedef boost::ptr_vector<Builder> PFRecoTauChargedHadronProducer::builderList

private

Definition at line 68 of file PFRecoTauChargedHadronProducer.cc.

typedef boost::ptr_list<reco::PFRecoTauChargedHadron> PFRecoTauChargedHadronProducer::ChargedHadronList

private

Definition at line 71 of file PFRecoTauChargedHadronProducer.cc.

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

private

Definition at line 73 of file PFRecoTauChargedHadronProducer.cc.

typedef boost::ptr_vector<reco::PFRecoTauChargedHadron> PFRecoTauChargedHadronProducer::ChargedHadronVector

private

Definition at line 70 of file PFRecoTauChargedHadronProducer.cc.

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

Definition at line 57 of file PFRecoTauChargedHadronProducer.cc.

typedef boost::ptr_vector<Ranker> PFRecoTauChargedHadronProducer::rankerList

private

Definition at line 69 of file PFRecoTauChargedHadronProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 96 of file PFRecoTauChargedHadronProducer.cc.

References edm::ParameterSet::addParameter(), builders_, beamerCreator::create(), timingPdfMaker::get, edm::ParameterSet::getParameter(), 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_.push_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_.push_back(PFRecoTauChargedHadronQualityPluginFactory::get()->create(pluginType, pset_modified));
   }
 
   // build the sorting predicate
   predicate_ = std::unique_ptr<ChargedHadronPredicate>(new ChargedHadronPredicate(rankers_));
 
   // check if we want to apply a final output selection
   std::string selection = cfg.getParameter<std::string>("outputSelection");
   if (!selection.empty()) {
     outputSelector_.reset(new StringCutObjectSelector<reco::PFRecoTauChargedHadron>(selection));
   }
 
   produces<reco::PFJetChargedHadronAssociation>();
 }

PFRecoTauChargedHadronProducer::~PFRecoTauChargedHadronProducer ( )

inlineoverride

Definition at line 60 of file PFRecoTauChargedHadronProducer.cc.

References fillDescriptions(), print(), and produce().

60 {}

Member Function Documentation

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

static

Definition at line 336 of file PFRecoTauChargedHadronProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), DEFINE_FWK_MODULE, HLT_2018_cff::InputTag, beam_dqm_sourceclient-live_cfg::qualityCuts, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by ~PFRecoTauChargedHadronProducer().

                                                                                                 {
   // 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 pset_signalQualityCuts;
       pset_signalQualityCuts.add<double>("maxDeltaZ", 0.4);
       pset_signalQualityCuts.add<double>("minTrackPt", 0.5);
       pset_signalQualityCuts.add<double>("minTrackVertexWeight", -1.0);
       pset_signalQualityCuts.add<double>("maxTrackChi2", 100.0);
       pset_signalQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
       pset_signalQualityCuts.add<double>("minGammaEt", 1.0);
       pset_signalQualityCuts.add<unsigned int>("minTrackHits", 3);
       pset_signalQualityCuts.add<double>("minNeutralHadronEt", 30.0);
       pset_signalQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
       pset_signalQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
 
       edm::ParameterSetDescription pset_vxAssocQualityCuts;
       pset_vxAssocQualityCuts.add<double>("minTrackPt", 0.5);
       pset_vxAssocQualityCuts.add<double>("minTrackVertexWeight", -1.0);
       pset_vxAssocQualityCuts.add<double>("maxTrackChi2", 100.0);
       pset_vxAssocQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
       pset_vxAssocQualityCuts.add<double>("minGammaEt", 1.0);
       pset_vxAssocQualityCuts.add<unsigned int>("minTrackHits", 3);
       pset_vxAssocQualityCuts.add<double>("maxTransverseImpactParameter", 0.1);
       pset_vxAssocQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
 
       edm::ParameterSetDescription pset_isolationQualityCuts;
       pset_isolationQualityCuts.add<double>("maxDeltaZ", 0.2);
       pset_isolationQualityCuts.add<double>("minTrackPt", 1.0);
       pset_isolationQualityCuts.add<double>("minTrackVertexWeight", -1.0);
       pset_isolationQualityCuts.add<double>("maxTrackChi2", 100.0);
       pset_isolationQualityCuts.add<unsigned int>("minTrackPixelHits", 0);
       pset_isolationQualityCuts.add<double>("minGammaEt", 1.5);
       pset_isolationQualityCuts.add<unsigned int>("minTrackHits", 8);
       pset_isolationQualityCuts.add<double>("maxTransverseImpactParameter", 0.03);
       pset_isolationQualityCuts.addOptional<bool>("useTracksInsteadOfPFHadrons");
 
       edm::ParameterSetDescription pset_qualityCuts;
       pset_qualityCuts.add<edm::ParameterSetDescription>("signalQualityCuts", pset_signalQualityCuts);
       pset_qualityCuts.add<edm::ParameterSetDescription>("vxAssocQualityCuts", pset_vxAssocQualityCuts);
       pset_qualityCuts.add<edm::ParameterSetDescription>("isolationQualityCuts", pset_isolationQualityCuts);
       pset_qualityCuts.add<std::string>("leadingTrkOrPFCandOption", "leadPFCand");
       pset_qualityCuts.add<std::string>("pvFindingAlgo", "closestInDeltaZ");
       pset_qualityCuts.add<edm::InputTag>("primaryVertexSrc", edm::InputTag("offlinePrimaryVertices"));
       pset_qualityCuts.add<bool>("vertexTrackFiltering", false);
       pset_qualityCuts.add<bool>("recoverLeadingTrk", false);
 
       desc_builders.add<edm::ParameterSetDescription>("qualityCuts", pset_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);
 }

template<typename T >

void PFRecoTauChargedHadronProducer::print ( const T & chargedHadrons )

Definition at line 322 of file PFRecoTauChargedHadronProducer.cc.

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

Referenced by produce(), and ~PFRecoTauChargedHadronProducer().

                                                                   {
   for (typename T::const_iterator chargedHadron = chargedHadrons.begin(); chargedHadron != chargedHadrons.end();
        ++chargedHadron) {
     edm::LogPrint("PFRecoTauChHProducer") << (*chargedHadron);
     edm::LogPrint("PFRecoTauChHProducer") << "Rankers:";
     for (rankerList::const_iterator ranker = rankers_.begin(); ranker != rankers_.end(); ++ranker) {
       const 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;
     }
   }
 }

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

override

Definition at line 135 of file PFRecoTauChargedHadronProducer.cc.

References funct::abs(), builders_, PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, MillePedeFileConverter_cfg::e, edm::RefToBaseVector< T >::empty(), reco::TrackBase::eta(), cppFunctionSkipper::exception, edm::Ref< C, T, F >::get(), edm::Event::getByToken(), reco::PFCandidate::gsfTrackRef(), mps_fire::i, edm::Ref< C, T, F >::isNonnull(), singleTopDQM_cfi::jets, Jets_token, reco::PFRecoTauChargedHadron::kPFNeutralHadron, maxJetAbsEta_, minJetPt_, moduleLabel_, eostools::move(), reco::PFCandidate::muonRef(), outputSelector_, pfJetBenchmark_cfi::pfJets, reco::TrackBase::phi(), predicate_, print(), edm::RefToBaseVector< T >::push_back(), edm::Event::put(), edm::View< T >::refAt(), mps_fire::result, reco::tau::setChargedHadronP4(), edm::View< T >::size(), HLT_2018_cff::track, reco::PFCandidate::trackRef(), and verbosity_.

Referenced by ~PFRecoTauChargedHadronProducer().

                                                                                    {
   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() << ":";
           print(result);
         }
         uncleanedChargedHadrons.transfer(uncleanedChargedHadrons.end(), result);
       } 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(*predicate_);
 
     // 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(uncleanedChargedHadrons.pop_front().release());
       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 = nullptr;
       if (nextChargedHadron->getChargedPFCandidate().isNonnull()) {
         const reco::PFCandidate* chargedPFCand =
             dynamic_cast<const reco::PFCandidate*>(&*nextChargedHadron->getChargedPFCandidate());
         if (chargedPFCand) {
           if (chargedPFCand->trackRef().isNonnull())
             track = chargedPFCand->trackRef().get();
           else if (chargedPFCand->muonRef().isNonnull() && chargedPFCand->muonRef()->innerTrack().isNonnull())
             track = chargedPFCand->muonRef()->innerTrack().get();
           else if (chargedPFCand->muonRef().isNonnull() && chargedPFCand->muonRef()->globalTrack().isNonnull())
             track = chargedPFCand->muonRef()->globalTrack().get();
           else if (chargedPFCand->muonRef().isNonnull() && chargedPFCand->muonRef()->outerTrack().isNonnull())
             track = chargedPFCand->muonRef()->outerTrack().get();
           else if (chargedPFCand->gsfTrackRef().isNonnull())
             track = chargedPFCand->gsfTrackRef().get();
         }
       }
       if (nextChargedHadron->getTrack().isNonnull() && !track) {
         track = nextChargedHadron->getTrack().get();
       }
 
       // 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
         ChargedHadronList::iterator insertionPoint = std::lower_bound(
             uncleanedChargedHadrons.begin(), uncleanedChargedHadrons.end(), *nextChargedHadron, *predicate_);
         if (verbosity_) {
           edm::LogPrint("PFRecoTauChHProducer") << "--> removing non-unique neutral PFCandidates and reinserting "
                                                    "nextChargedHadron in uncleaned collection.";
         }
         uncleanedChargedHadrons.insert(insertionPoint, std::move(nextChargedHadron));
       }
     }
 
     if (verbosity_) {
       print(cleanedChargedHadrons);
     }
 
     // add ChargedHadron-to-jet association
     pfJetChargedHadronAssociations->setValue(pfJet.key(), cleanedChargedHadrons);
   }
 
   evt.put(std::move(pfJetChargedHadronAssociations));
 }