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

bool	hasAbilityToProduceInRuns () 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::auto_ptr< StringCutObjectSelector< reco::PFRecoTauChargedHadron > >	outputSelector_

std::auto_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 57 of file PFRecoTauChargedHadronProducer.cc.

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

private

Definition at line 69 of file PFRecoTauChargedHadronProducer.cc.

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

private

Definition at line 72 of file PFRecoTauChargedHadronProducer.cc.

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

private

Definition at line 74 of file PFRecoTauChargedHadronProducer.cc.

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

private

Definition at line 71 of file PFRecoTauChargedHadronProducer.cc.

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

Definition at line 58 of file PFRecoTauChargedHadronProducer.cc.

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

private

Definition at line 70 of file PFRecoTauChargedHadronProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 97 of file PFRecoTauChargedHadronProducer.cc.

References edm::ParameterSet::addParameter(), builders_, beamerCreator::create(), reco::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::auto_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 61 of file PFRecoTauChargedHadronProducer.cc.

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

61 {}

Member Function Documentation

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

static

Definition at line 325 of file PFRecoTauChargedHadronProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), edm::ParameterSetDescription::addVPSet(), DEFINE_FWK_MODULE, CaloRecoTauDiscriminationByFlightPathSignificance_cfi::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 309 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 138 of file PFRecoTauChargedHadronProducer.cc.

References funct::abs(), builders_, boostedElectronIsolation_cff::deltaR, PFRecoTauDiscriminationAgainstElectronDeadECAL_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(), fwrapper::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(), HiIsolationCommonParameters_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::auto_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, nextChargedHadron);
       }
     }
 
     if ( verbosity_ ) {
       print(cleanedChargedHadrons);
     }
 
     // add ChargedHadron-to-jet association
     pfJetChargedHadronAssociations->setValue(pfJet.key(), cleanedChargedHadrons);
   }
 
   evt.put(std::move(pfJetChargedHadronAssociations));
 }