PFRecoTauChargedHadronProducer Class Reference

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

Builder

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

Definition at line 56 of file PFRecoTauChargedHadronProducer.cc.

builderList

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

private

Definition at line 68 of file PFRecoTauChargedHadronProducer.cc.

ChargedHadronList

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

private

Definition at line 71 of file PFRecoTauChargedHadronProducer.cc.

ChargedHadronPredicate

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

private

Definition at line 73 of file PFRecoTauChargedHadronProducer.cc.

ChargedHadronVector

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

private

Definition at line 70 of file PFRecoTauChargedHadronProducer.cc.

Ranker

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

Definition at line 57 of file PFRecoTauChargedHadronProducer.cc.

rankerList

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

private

Definition at line 69 of file PFRecoTauChargedHadronProducer.cc.

Constructor & Destructor Documentation

PFRecoTauChargedHadronProducer()

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

explicit

Definition at line 96 of file PFRecoTauChargedHadronProducer.cc.

    : 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>();
}

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_.

~PFRecoTauChargedHadronProducer()

PFRecoTauChargedHadronProducer::~PFRecoTauChargedHadronProducer ( )

inlineoverride

Definition at line 60 of file PFRecoTauChargedHadronProducer.cc.

{}

Member Function Documentation

fillDescriptions()

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

static

Definition at line 336 of file PFRecoTauChargedHadronProducer.cc.

                                                                                                {
  // 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);
}

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

print()

template<typename T >

void PFRecoTauChargedHadronProducer::print

(

const T &

chargedHadrons

)

Definition at line 322 of file PFRecoTauChargedHadronProducer.cc.

                                                                  {
  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;
    }
  }
}

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

Referenced by produce().

produce()

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

override

Definition at line 135 of file PFRecoTauChargedHadronProducer.cc.

                                                                                   {
  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));
}

References funct::abs(), builders_, PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, MillePedeFileConverter_cfg::e, 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, cuda_std::lower_bound(), maxJetAbsEta_, minJetPt_, moduleLabel_, eostools::move(), reco::PFCandidate::muonRef(), outputSelector_, pfJetBenchmark_cfi::pfJets, predicate_, print(), edm::Event::put(), mps_fire::result, reco::tau::setChargedHadronP4(), HLT_2018_cff::track, reco::PFCandidate::trackRef(), and verbosity_.

Member Data Documentation

builders_

builderList PFRecoTauChargedHadronProducer::builders_

private

Definition at line 84 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

Jets_token

edm::EDGetTokenT<reco::JetView> PFRecoTauChargedHadronProducer::Jets_token

private

Definition at line 79 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

maxJetAbsEta_

double PFRecoTauChargedHadronProducer::maxJetAbsEta_

private

Definition at line 81 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

minJetPt_

double PFRecoTauChargedHadronProducer::minJetPt_

private

Definition at line 80 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

moduleLabel_

std::string PFRecoTauChargedHadronProducer::moduleLabel_

private

Definition at line 75 of file PFRecoTauChargedHadronProducer.cc.

Referenced by ExternalGeneratorFilter.ExternalGeneratorFilter::insertInto(), Modules.SwitchProducer::insertInto(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), and produce().

outputSelector_

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

private

Definition at line 90 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

predicate_

std::unique_ptr<ChargedHadronPredicate> PFRecoTauChargedHadronProducer::predicate_

private

Definition at line 87 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

rankers_

rankerList PFRecoTauChargedHadronProducer::rankers_

private

Definition at line 85 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and print().

srcJets_

edm::InputTag PFRecoTauChargedHadronProducer::srcJets_

private

Definition at line 78 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer().

verbosity_

int PFRecoTauChargedHadronProducer::verbosity_

private

Definition at line 93 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().