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	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () 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 57 of file PFRecoTauChargedHadronProducer.cc.

Member Typedef Documentation

Builder

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

Definition at line 59 of file PFRecoTauChargedHadronProducer.cc.

builderList

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

private

Definition at line 71 of file PFRecoTauChargedHadronProducer.cc.

ChargedHadronList

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

private

Definition at line 74 of file PFRecoTauChargedHadronProducer.cc.

ChargedHadronPredicate

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

private

Definition at line 76 of file PFRecoTauChargedHadronProducer.cc.

ChargedHadronVector

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

private

Definition at line 73 of file PFRecoTauChargedHadronProducer.cc.

Ranker

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

Definition at line 60 of file PFRecoTauChargedHadronProducer.cc.

rankerList

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

private

Definition at line 72 of file PFRecoTauChargedHadronProducer.cc.

Constructor & Destructor Documentation

PFRecoTauChargedHadronProducer()

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

explicit

Definition at line 99 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::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>();
}

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 63 of file PFRecoTauChargedHadronProducer.cc.

{}

Member Function Documentation

fillDescriptions()

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

static

Definition at line 339 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 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);
}

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSet::addParameter(), submitPVResolutionJobs::desc, reco::tau::RecoTauQualityCuts::fillDescriptions(), HLT_FULL_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 325 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 138 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, pfDeepBoostedJetPreprocessParams_cfi::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_FULL_cff::track, reco::PFCandidate::trackRef(), and verbosity_.

Member Data Documentation

builders_

builderList PFRecoTauChargedHadronProducer::builders_

private

Definition at line 87 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

Jets_token

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

private

Definition at line 82 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

maxJetAbsEta_

double PFRecoTauChargedHadronProducer::maxJetAbsEta_

private

Definition at line 84 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

minJetPt_

double PFRecoTauChargedHadronProducer::minJetPt_

private

Definition at line 83 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

moduleLabel_

std::string PFRecoTauChargedHadronProducer::moduleLabel_

private

Definition at line 78 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 93 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

predicate_

std::unique_ptr<ChargedHadronPredicate> PFRecoTauChargedHadronProducer::predicate_

private

Definition at line 90 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().

rankers_

rankerList PFRecoTauChargedHadronProducer::rankers_

private

Definition at line 88 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and print().

srcJets_

edm::InputTag PFRecoTauChargedHadronProducer::srcJets_

private

Definition at line 81 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer().

verbosity_

int PFRecoTauChargedHadronProducer::verbosity_

private

Definition at line 96 of file PFRecoTauChargedHadronProducer.cc.

Referenced by PFRecoTauChargedHadronProducer(), and produce().