Inheritance diagram for PFRecoTauDiscriminationByIsolation:

Classes
struct	FootprintCorrection

Public Member Functions
void	beginEvent (const edm::Event &evt, const edm::EventSetup &evtSetup) override

double	discriminate (const PFTauRef &pfTau) const override

	PFRecoTauDiscriminationByIsolation (const edm::ParameterSet &pset)

double	weightedSum (const std::vector< CandidatePtr > &inColl_, double eta, double phi) const

	~PFRecoTauDiscriminationByIsolation () override

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
virtual TauDiscriminatorDataType	discriminate (const TauRef &tau) const =0

virtual void	endEvent (edm::Event &)

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

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

	~TauDiscriminationProducerBase () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
static void	fillProducerDescriptions (edm::ParameterSetDescription &desc)

static std::string	getTauTypeString ()
	helper method to retrieve tau type name, e.g. to build correct cfi getter More...

Private Attributes
bool	applyDeltaBeta_

bool	applyFootprintCorrection_

bool	applyOccupancyCut_

bool	applyPhotonPtSumOutsideSignalConeCut_

bool	applyRelativeSumPtCut_

bool	applyRhoCorrection_

bool	applySumPtCut_

bool	calculateWeights_

std::vector< reco::CandidatePtr >	chargedPFCandidatesInEvent_

double	customIsoCone_

double	deltaBetaCollectionCone_

double	deltaBetaFactorThisEvent_

std::unique_ptr< TFormula >	deltaBetaFormula_

bool	enableHGCalWorkaround_

std::vector< std::unique_ptr< FootprintCorrection > >	footprintCorrections_

bool	includeGammas_

bool	includeTracks_

double	maxAbsPhotonSumPt_outsideSignalCone_

uint32_t	maximumOccupancy_

double	maximumRelativeSumPt_

double	maximumSumPt_

double	maxRelPhotonSumPt_outsideSignalCone_

double	minPtForNoIso_

std::string	moduleLabel_

double	offsetRelativeSumPt_

edm::EDGetTokenT< edm::View< reco::Candidate > >	pfCand_token

edm::InputTag	pfCandSrc_

std::unique_ptr< tau::RecoTauQualityCuts >	pileupQcutsGeneralQCuts_

std::unique_ptr< tau::RecoTauQualityCuts >	pileupQcutsPUTrackSelection_

std::unique_ptr< tau::RecoTauQualityCuts >	qcuts_

edm::ParameterSet	qualityCutsPSet_

edm::EDGetTokenT< double >	rho_token

double	rhoConeSize_

double	rhoCorrectionThisEvent_

edm::InputTag	rhoProducer_

double	rhoThisEvent_

double	rhoUEOffsetCorrection_

bool	storeRawFootprintCorrection_

bool	storeRawOccupancy_

bool	storeRawPhotonSumPt_outsideSignalCone_

bool	storeRawPUsumPt_

bool	storeRawSumPt_

bool	useAllPFCands_

int	verbosity_

edm::EDGetTokenT< reco::VertexCollection >	vertex_token

std::unique_ptr< tau::RecoTauVertexAssociator >	vertexAssociator_

edm::InputTag	vertexSrc_

double	weightGammas_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
typedef std::vector< TauType >	TauCollection

typedef edm::Ref< TauCollection >	TauRef

typedef edm::RefProd< TauCollection >	TauRefProd

Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >
std::string	moduleLabel_

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 30 of file PFRecoTauDiscriminationByIsolation.cc.

Constructor & Destructor Documentation

◆ PFRecoTauDiscriminationByIsolation()

PFRecoTauDiscriminationByIsolation::PFRecoTauDiscriminationByIsolation ( const edm::ParameterSet & pset )

inlineexplicit

Definition at line 32 of file PFRecoTauDiscriminationByIsolation.cc.

References HLT_2023v12_cff::deltaBetaPUTrackPtCutOverride, HLT_2023v12_cff::deltaBetaPUTrackPtCutOverride_val, Exception, reco::tau::factorizePUQCuts(), deep_tau::FootprintCorrection, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), eostools::move(), hltrates_dqm_sourceclient-live_cfg::offset, muonDTDigis_cfi::pset, corrVsCorr::selection, and AlCaHLTBitMon_QueryRunRegistry::string.

       : PFTauDiscriminationProducerBase(pset),
         moduleLabel_(pset.getParameter<std::string>("@module_label")),
         qualityCutsPSet_(pset.getParameter<edm::ParameterSet>("qualityCuts")) {
     includeTracks_ = pset.getParameter<bool>("ApplyDiscriminationByTrackerIsolation");
     includeGammas_ = pset.getParameter<bool>("ApplyDiscriminationByECALIsolation");
 
     calculateWeights_ = pset.getParameter<bool>("ApplyDiscriminationByWeightedECALIsolation");
 
     enableHGCalWorkaround_ = pset.getParameter<bool>("enableHGCalWorkaround");
 
     // RIC: multiply neutral isolation by a flat factor.
     //      Useful, for instance, to combine charged and neutral isolations
     //      with different relative weights
     weightGammas_ = pset.getParameter<double>("WeightECALIsolation");
 
     // RIC: allow to relax the isolation completely beyond a given tau pt
     minPtForNoIso_ = pset.getParameter<double>("minTauPtForNoIso");
 
     applyOccupancyCut_ = pset.getParameter<bool>("applyOccupancyCut");
     maximumOccupancy_ = pset.getParameter<uint32_t>("maximumOccupancy");
 
     applySumPtCut_ = pset.getParameter<bool>("applySumPtCut");
     maximumSumPt_ = pset.getParameter<double>("maximumSumPtCut");
 
     applyRelativeSumPtCut_ = pset.getParameter<bool>("applyRelativeSumPtCut");
     maximumRelativeSumPt_ = pset.getParameter<double>("relativeSumPtCut");
     offsetRelativeSumPt_ = pset.getParameter<double>("relativeSumPtOffset");
 
     storeRawOccupancy_ = pset.getParameter<bool>("storeRawOccupancy");
     storeRawSumPt_ = pset.getParameter<bool>("storeRawSumPt");
     storeRawPUsumPt_ = pset.getParameter<bool>("storeRawPUsumPt");
     storeRawFootprintCorrection_ = pset.getParameter<bool>("storeRawFootprintCorrection");
     storeRawPhotonSumPt_outsideSignalCone_ = pset.getParameter<bool>("storeRawPhotonSumPt_outsideSignalCone");
 
     // Sanity check on requested options.  We can't apply cuts and store the
     // raw output at the same time
     if (applySumPtCut_ || applyOccupancyCut_ || applyRelativeSumPtCut_) {
       if (storeRawSumPt_ || storeRawOccupancy_ || storeRawPUsumPt_) {
         throw cms::Exception("BadIsoConfig") << "A 'store raw' and a 'apply cut' option have been set to true "
                                              << "simultaneously.  These options are mutually exclusive.";
       }
     }
 
     // sanity check2 - can't use weighted and unweighted iso at the same time
     if (includeGammas_ && calculateWeights_) {
       throw cms::Exception("BasIsoConfig")
           << "Both 'ApplyDiscriminationByECALIsolation' and 'ApplyDiscriminationByWeightedECALIsolation' "
           << "have been set to true. These options are mutually exclusive.";
     }
 
     // Can only store one type
     int numStoreOptions = 0;
     if (storeRawSumPt_)
       ++numStoreOptions;
     if (storeRawOccupancy_)
       ++numStoreOptions;
     if (storeRawPUsumPt_)
       ++numStoreOptions;
     if (storeRawFootprintCorrection_)
       ++numStoreOptions;
     if (storeRawPhotonSumPt_outsideSignalCone_)
       ++numStoreOptions;
     if (numStoreOptions > 1) {
       throw cms::Exception("BadIsoConfig") << "Multiple 'store sum pt' and/or 'store occupancy' options are set."
                                            << " These options are mutually exclusive.";
     }
 
     customIsoCone_ = pset.getParameter<double>("customOuterCone");
 
     applyPhotonPtSumOutsideSignalConeCut_ = pset.getParameter<bool>("applyPhotonPtSumOutsideSignalConeCut");
     if (applyPhotonPtSumOutsideSignalConeCut_) {
       maxAbsPhotonSumPt_outsideSignalCone_ = pset.getParameter<double>("maxAbsPhotonSumPt_outsideSignalCone");
       maxRelPhotonSumPt_outsideSignalCone_ = pset.getParameter<double>("maxRelPhotonSumPt_outsideSignalCone");
     }
 
     applyFootprintCorrection_ = pset.getParameter<bool>("applyFootprintCorrection");
     if (applyFootprintCorrection_ || storeRawFootprintCorrection_) {
       edm::VParameterSet cfgFootprintCorrections = pset.getParameter<edm::VParameterSet>("footprintCorrections");
       for (edm::VParameterSet::const_iterator cfgFootprintCorrection = cfgFootprintCorrections.begin();
            cfgFootprintCorrection != cfgFootprintCorrections.end();
            ++cfgFootprintCorrection) {
         std::string selection = cfgFootprintCorrection->getParameter<std::string>("selection");
         std::string offset = cfgFootprintCorrection->getParameter<std::string>("offset");
         std::unique_ptr<FootprintCorrection> footprintCorrection(new FootprintCorrection(selection, offset));
         footprintCorrections_.push_back(std::move(footprintCorrection));
       }
     }
 
     // Get the quality cuts specific to the isolation region
     edm::ParameterSet isolationQCuts = qualityCutsPSet_.getParameterSet("isolationQualityCuts");
 
     qcuts_ = std::make_unique<tau::RecoTauQualityCuts>(isolationQCuts);
 
     vertexAssociator_ = std::make_unique<tau::RecoTauVertexAssociator>(qualityCutsPSet_, consumesCollector());
 
     applyDeltaBeta_ = pset.getParameter<bool>("applyDeltaBetaCorrection");
 
     if (applyDeltaBeta_ || calculateWeights_) {
       // Factorize the isolation QCuts into those that are used to
       // select PU and those that are not.
       std::pair<edm::ParameterSet, edm::ParameterSet> puFactorizedIsoQCuts =
           reco::tau::factorizePUQCuts(isolationQCuts);
 
       // Determine the pt threshold for the PU tracks
       // First check if the user specifies explicitly the cut.
       // For that the user has to provide a >= 0  value for the PtCutOverride.
       bool deltaBetaPUTrackPtCutOverride = pset.getParameter<bool>("deltaBetaPUTrackPtCutOverride");
       if (deltaBetaPUTrackPtCutOverride) {
         double deltaBetaPUTrackPtCutOverride_val = pset.getParameter<double>("deltaBetaPUTrackPtCutOverride_val");
         puFactorizedIsoQCuts.second.addParameter<double>("minTrackPt", deltaBetaPUTrackPtCutOverride_val);
       } else {
         // Secondly take it from the minGammaEt
         puFactorizedIsoQCuts.second.addParameter<double>("minTrackPt",
                                                          isolationQCuts.getParameter<double>("minGammaEt"));
       }
 
       pileupQcutsPUTrackSelection_ = std::make_unique<tau::RecoTauQualityCuts>(puFactorizedIsoQCuts.first);
 
       pileupQcutsGeneralQCuts_ = std::make_unique<tau::RecoTauQualityCuts>(puFactorizedIsoQCuts.second);
 
       pfCandSrc_ = pset.getParameter<edm::InputTag>("particleFlowSrc");
       pfCand_token = consumes<edm::View<reco::Candidate> >(pfCandSrc_);
       vertexSrc_ = pset.getParameter<edm::InputTag>("vertexSrc");
       vertex_token = consumes<reco::VertexCollection>(vertexSrc_);
       deltaBetaCollectionCone_ = pset.getParameter<double>("isoConeSizeForDeltaBeta");
       std::string deltaBetaFactorFormula = pset.getParameter<string>("deltaBetaFactor");
       deltaBetaFormula_ = std::make_unique<TFormula>("DB_corr", deltaBetaFactorFormula.c_str());
     }
 
     applyRhoCorrection_ = pset.getParameter<bool>("applyRhoCorrection");
     if (applyRhoCorrection_) {
       rhoProducer_ = pset.getParameter<edm::InputTag>("rhoProducer");
       rho_token = consumes<double>(rhoProducer_);
       rhoConeSize_ = pset.getParameter<double>("rhoConeSize");
       rhoUEOffsetCorrection_ = pset.getParameter<double>("rhoUEOffsetCorrection");
     }
     useAllPFCands_ = pset.getParameter<bool>("UseAllPFCandsForWeights");
 
     verbosity_ = pset.getParameter<int>("verbosity");
   }

◆ ~PFRecoTauDiscriminationByIsolation()

PFRecoTauDiscriminationByIsolation::~PFRecoTauDiscriminationByIsolation ( )

inlineoverride

Definition at line 174 of file PFRecoTauDiscriminationByIsolation.cc.

174 {}

Member Function Documentation

◆ beginEvent()

void PFRecoTauDiscriminationByIsolation::beginEvent	(	const edm::Event &	evt,
		const edm::EventSetup &	evtSetup
	)

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator, TauDiscriminatorDataType, ConsumeType >.

Definition at line 271 of file PFRecoTauDiscriminationByIsolation.cc.

References reco::Candidate::charge(), mps_fire::i, zmumugammaAnalyzer_cfi::pfCandidates, and AlignmentTracksFromVertexSelector_cfi::vertices.

                                                                                                           {
   // NB: The use of the PV in this context is necessitated by its use in
   // applying quality cuts to the different objects in the isolation cone
   // The vertex associator contains the logic to select the appropriate vertex
   // We need to pass it the event so it can load the vertices.
   vertexAssociator_->setEvent(event);
 
   // If we are applying the delta beta correction, we need to get the PF
   // candidates from the event so we can find the PU tracks.
   if (applyDeltaBeta_ || calculateWeights_) {
     // Collect all the PF pile up tracks
     edm::Handle<edm::View<reco::Candidate> > pfCandidates;
     event.getByToken(pfCand_token, pfCandidates);
     chargedPFCandidatesInEvent_.clear();
     chargedPFCandidatesInEvent_.reserve(pfCandidates->size());
     size_t numPFCandidates = pfCandidates->size();
     for (size_t i = 0; i < numPFCandidates; ++i) {
       reco::CandidatePtr pfCandidate(pfCandidates, i);
       if (pfCandidate->charge() != 0) {
         chargedPFCandidatesInEvent_.push_back(pfCandidate);
       }
     }
     // Count all the vertices in the event, to parameterize the DB
     // correction factor
     edm::Handle<reco::VertexCollection> vertices;
     event.getByToken(vertex_token, vertices);
     size_t nVtxThisEvent = vertices->size();
     deltaBetaFactorThisEvent_ = deltaBetaFormula_->Eval(nVtxThisEvent);
   }
 
   if (applyRhoCorrection_) {
     edm::Handle<double> rhoHandle_;
     event.getByToken(rho_token, rhoHandle_);
     rhoThisEvent_ = (*rhoHandle_ - rhoUEOffsetCorrection_) * (3.14159) * rhoConeSize_ * rhoConeSize_;
   }
 }

◆ discriminate()

double PFRecoTauDiscriminationByIsolation::discriminate ( const PFTauRef & pfTau ) const

override

Definition at line 308 of file PFRecoTauDiscriminationByIsolation.cc.

References gather_cfg::cout, reco::deltaR(), HGC3DClusterGenMatchSelector_cfi::dR, PVValHelper::eta, ALCARECOTkAlBeamHalo_cff::filter, edm::Ref< C, T, F >::isNonnull(), dqm-mbProfile::log, LogDebug, LogTrace, SiStripPI::min, eostools::move(), reco::LeafCandidate::p4(), edm::OwnVector< T, P >::push_back(), edm::OwnVector< T, P >::reserve(), reco::LeafCandidate::setP4(), edm::OwnVector< T, P >::size(), listHistos::trackPt, and trackerHitRTTI::vector.

                                                                                    {
   LogDebug("discriminate") << " tau: Pt = " << pfTau->pt() << ", eta = " << pfTau->eta() << ", phi = " << pfTau->phi();
   LogDebug("discriminate") << *pfTau;
 
   // collect the objects we are working with (ie tracks, tracks+gammas, etc)
   std::vector<CandidatePtr> isoCharged_;
   std::vector<CandidatePtr> isoNeutral_;
   std::vector<CandidatePtr> isoPU_;
   CandidateCollection isoNeutralWeight_;
   std::vector<CandidatePtr> chPV_;
   isoCharged_.reserve(pfTau->isolationChargedHadrCands().size());
   isoNeutral_.reserve(pfTau->isolationGammaCands().size());
   isoPU_.reserve(std::min(100UL, chargedPFCandidatesInEvent_.size()));
   isoNeutralWeight_.reserve(pfTau->isolationGammaCands().size());
 
   chPV_.reserve(std::min(50UL, chargedPFCandidatesInEvent_.size()));
 
   // Get the primary vertex associated to this tau
   reco::VertexRef pv = vertexAssociator_->associatedVertex(*pfTau);
   // Let the quality cuts know which the vertex to use when applying selections
   // on dz, etc.
   if (verbosity_) {
     if (pv.isNonnull()) {
       LogTrace("discriminate") << "pv: x = " << pv->position().x() << ", y = " << pv->position().y()
                                << ", z = " << pv->position().z();
     } else {
       LogTrace("discriminate") << "pv: N/A";
     }
     if (pfTau->leadChargedHadrCand().isNonnull()) {
       LogTrace("discriminate") << "leadPFChargedHadron:"
                                << " Pt = " << pfTau->leadChargedHadrCand()->pt() << ","
                                << " eta = " << pfTau->leadChargedHadrCand()->eta() << ","
                                << " phi = " << pfTau->leadChargedHadrCand()->phi();
     } else {
       LogTrace("discriminate") << "leadPFChargedHadron: N/A";
     }
   }
 
   // CV: isolation is not well defined in case primary vertex or leading charged hadron do not exist
   if (!(pv.isNonnull() && pfTau->leadChargedHadrCand().isNonnull()))
     return 0.;
 
   qcuts_->setPV(pv);
   qcuts_->setLeadTrack(*pfTau->leadChargedHadrCand());
 
   if (applyDeltaBeta_ || calculateWeights_) {
     pileupQcutsGeneralQCuts_->setPV(pv);
     pileupQcutsGeneralQCuts_->setLeadTrack(*pfTau->leadChargedHadrCand());
     pileupQcutsPUTrackSelection_->setPV(pv);
     pileupQcutsPUTrackSelection_->setLeadTrack(*pfTau->leadChargedHadrCand());
   }
 
   // Load the tracks if they are being used.
   if (includeTracks_) {
     for (auto const& cand : pfTau->isolationChargedHadrCands()) {
       if (qcuts_->filterCandRef(cand)) {
         LogTrace("discriminate") << "adding charged iso cand with pt " << cand->pt();
         isoCharged_.push_back(cand);
       }
     }
   }
   if (includeGammas_ || calculateWeights_) {
     for (auto const& cand : pfTau->isolationGammaCands()) {
       if (qcuts_->filterCandRef(cand)) {
         LogTrace("discriminate") << "adding neutral iso cand with pt " << cand->pt();
         isoNeutral_.push_back(cand);
       }
     }
   }
 
   typedef reco::tau::cone::DeltaRPtrFilter<CandidatePtr> DRFilter;
   typedef reco::tau::cone::DeltaRFilter<Candidate> DRFilter2;
 
   // If desired, get PU tracks.
   if (applyDeltaBeta_ || calculateWeights_) {
     // First select by inverted the DZ/track weight cuts. True = invert
     if (verbosity_) {
       std::cout << "Initial PFCands: " << chargedPFCandidatesInEvent_.size() << std::endl;
     }
 
     std::vector<CandidatePtr> allPU = pileupQcutsPUTrackSelection_->filterCandRefs(chargedPFCandidatesInEvent_, true);
 
     std::vector<CandidatePtr> allNPU = pileupQcutsPUTrackSelection_->filterCandRefs(chargedPFCandidatesInEvent_);
     LogTrace("discriminate") << "After track cuts: " << allPU.size();
 
     // Now apply the rest of the cuts, like pt, and TIP, tracker hits, etc
     if (!useAllPFCands_) {
       std::vector<CandidatePtr> cleanPU = pileupQcutsGeneralQCuts_->filterCandRefs(allPU);
 
       std::vector<CandidatePtr> cleanNPU = pileupQcutsGeneralQCuts_->filterCandRefs(allNPU);
 
       LogTrace("discriminate") << "After cleaning cuts: " << cleanPU.size();
 
       // Only select PU tracks inside the isolation cone.
       DRFilter deltaBetaFilter(pfTau->p4(), 0, deltaBetaCollectionCone_);
       for (auto const& cand : cleanPU) {
         if (deltaBetaFilter(cand))
           isoPU_.push_back(cand);
       }
 
       for (auto const& cand : cleanNPU) {
         if (deltaBetaFilter(cand))
           chPV_.push_back(cand);
       }
       LogTrace("discriminate") << "After cone cuts: " << isoPU_.size() << " " << chPV_.size();
     } else {
       isoPU_ = std::move(allPU);
       chPV_ = std::move(allNPU);
     }
   }
 
   if (calculateWeights_) {
     for (auto const& isoObject : isoNeutral_) {
       if (isoObject->charge() != 0) {
         // weight only neutral objects
         isoNeutralWeight_.push_back(*isoObject);
         continue;
       }
 
       double eta = isoObject->eta();
       double phi = isoObject->phi();
       double sumNPU = 0.5 * log(weightedSum(chPV_, eta, phi));
 
       double sumPU = 0.5 * log(weightedSum(isoPU_, eta, phi));
       LeafCandidate neutral(*isoObject);
       if ((sumNPU + sumPU) > 0)
         neutral.setP4(((sumNPU) / (sumNPU + sumPU)) * neutral.p4());
 
       isoNeutralWeight_.push_back(neutral);
     }
   }
 
   // Check if we want a custom iso cone
   if (customIsoCone_ >= 0.) {
     DRFilter filter(pfTau->p4(), 0, customIsoCone_);
     DRFilter2 filter2(pfTau->p4(), 0, customIsoCone_);
     std::vector<CandidatePtr> isoCharged_filter;
     std::vector<CandidatePtr> isoNeutral_filter;
     CandidateCollection isoNeutralWeight_filter;
     // Remove all the objects not in our iso cone
     for (auto const& isoObject : isoCharged_) {
       if (filter(isoObject))
         isoCharged_filter.push_back(isoObject);
     }
     if (!calculateWeights_) {
       for (auto const& isoObject : isoNeutral_) {
         if (filter(isoObject))
           isoNeutral_filter.push_back(isoObject);
       }
       isoNeutral_ = isoNeutral_filter;
     } else {
       for (auto const& isoObject : isoNeutralWeight_) {
         if (filter2(isoObject))
           isoNeutralWeight_filter.push_back(isoObject);
       }
       isoNeutralWeight_ = isoNeutralWeight_filter;
     }
     isoCharged_ = isoCharged_filter;
   }
 
   bool failsOccupancyCut = false;
   bool failsSumPtCut = false;
   bool failsRelativeSumPtCut = false;
 
   //--- nObjects requirement
   int neutrals = isoNeutral_.size();
 
   if (applyDeltaBeta_) {
     neutrals -= TMath::Nint(deltaBetaFactorThisEvent_ * isoPU_.size());
   }
   if (neutrals < 0) {
     neutrals = 0;
   }
 
   size_t nOccupants = isoCharged_.size() + neutrals;
 
   failsOccupancyCut = (nOccupants > maximumOccupancy_);
 
   double footprintCorrection_value = 0.;
   if (applyFootprintCorrection_ || storeRawFootprintCorrection_) {
     for (std::vector<std::unique_ptr<FootprintCorrection> >::const_iterator footprintCorrection =
              footprintCorrections_.begin();
          footprintCorrection != footprintCorrections_.end();
          ++footprintCorrection) {
       if ((*footprintCorrection)->selection_(*pfTau)) {
         footprintCorrection_value = (*footprintCorrection)->offset_(*pfTau);
       }
     }
   }
 
   double totalPt = 0.;
   double puPt = 0.;
   //--- Sum PT requirement
   if (applySumPtCut_ || applyRelativeSumPtCut_ || storeRawSumPt_ || storeRawPUsumPt_) {
     double chargedPt = 0.;
     double neutralPt = 0.;
     double weightedNeutralPt = 0.;
     for (auto const& isoObject : isoCharged_) {
       //-------------------------------------------------------------------------
       // CV: fix for Phase-2 HLT tau trigger studies
       //    (pT of PFCandidates within HGCal acceptance is significantly higher than track pT !!)
       if (enableHGCalWorkaround_) {
         double trackPt = (isoObject->bestTrack()) ? isoObject->bestTrack()->pt() : 0.;
         double pfCandPt = isoObject->pt();
         if (pfCandPt > trackPt) {
           chargedPt += trackPt;
           neutralPt += pfCandPt - trackPt;
         } else {
           chargedPt += isoObject->pt();
         }
       } else {
         chargedPt += isoObject->pt();
       }
       //-------------------------------------------------------------------------
     }
     if (!calculateWeights_) {
       for (auto const& isoObject : isoNeutral_) {
         neutralPt += isoObject->pt();
       }
     } else {
       for (auto const& isoObject : isoNeutralWeight_) {
         weightedNeutralPt += isoObject.pt();
       }
     }
     for (auto const& isoObject : isoPU_) {
       puPt += isoObject->pt();
     }
     LogTrace("discriminate") << "chargedPt = " << chargedPt;
     LogTrace("discriminate") << "neutralPt = " << neutralPt;
     LogTrace("discriminate") << "weighted neutral Pt = " << weightedNeutralPt;
     LogTrace("discriminate") << "puPt = " << puPt << " (delta-beta corr. = " << (deltaBetaFactorThisEvent_ * puPt)
                              << ")";
 
     if (calculateWeights_) {
       neutralPt = weightedNeutralPt;
     }
 
     if (applyDeltaBeta_) {
       neutralPt -= (deltaBetaFactorThisEvent_ * puPt);
     }
 
     if (applyFootprintCorrection_) {
       neutralPt -= footprintCorrection_value;
     }
 
     if (applyRhoCorrection_) {
       neutralPt -= rhoThisEvent_;
     }
 
     if (neutralPt < 0.) {
       neutralPt = 0.;
     }
 
     totalPt = chargedPt + weightGammas_ * neutralPt;
     LogTrace("discriminate") << "totalPt = " << totalPt << " (cut = " << maximumSumPt_ << ")";
 
     failsSumPtCut = (totalPt > maximumSumPt_);
 
     //--- Relative Sum PT requirement
     failsRelativeSumPtCut = (totalPt > ((pfTau->pt() - offsetRelativeSumPt_) * maximumRelativeSumPt_));
   }
 
   bool failsPhotonPtSumOutsideSignalConeCut = false;
   double photonSumPt_outsideSignalCone = 0.;
   if (applyPhotonPtSumOutsideSignalConeCut_ || storeRawPhotonSumPt_outsideSignalCone_) {
     const std::vector<reco::CandidatePtr>& signalGammas = pfTau->signalGammaCands();
     for (std::vector<reco::CandidatePtr>::const_iterator signalGamma = signalGammas.begin();
          signalGamma != signalGammas.end();
          ++signalGamma) {
       double dR = deltaR(pfTau->eta(), pfTau->phi(), (*signalGamma)->eta(), (*signalGamma)->phi());
       if (dR > pfTau->signalConeSize())
         photonSumPt_outsideSignalCone += (*signalGamma)->pt();
     }
     if (photonSumPt_outsideSignalCone > maxAbsPhotonSumPt_outsideSignalCone_ ||
         photonSumPt_outsideSignalCone > (maxRelPhotonSumPt_outsideSignalCone_ * pfTau->pt())) {
       failsPhotonPtSumOutsideSignalConeCut = true;
     }
   }
 
   bool fails = (applyOccupancyCut_ && failsOccupancyCut) || (applySumPtCut_ && failsSumPtCut) ||
                (applyRelativeSumPtCut_ && failsRelativeSumPtCut) ||
                (applyPhotonPtSumOutsideSignalConeCut_ && failsPhotonPtSumOutsideSignalConeCut);
 
   if (pfTau->pt() > minPtForNoIso_ && minPtForNoIso_ > 0.) {
     return 1.;
     LogDebug("discriminate") << "tau pt = " << pfTau->pt() << "\t  min cutoff pt = " << minPtForNoIso_;
   }
 
   // We did error checking in the constructor, so this is safe.
   if (storeRawSumPt_) {
     return totalPt;
   } else if (storeRawPUsumPt_) {
     if (applyDeltaBeta_)
       return puPt;
     else if (applyRhoCorrection_)
       return rhoThisEvent_;
     else
       return 0.;
   } else if (storeRawOccupancy_) {
     return nOccupants;
   } else if (storeRawFootprintCorrection_) {
     return footprintCorrection_value;
   } else if (storeRawPhotonSumPt_outsideSignalCone_) {
     return photonSumPt_outsideSignalCone;
   } else {
     return (fails ? 0. : 1.);
   }
 }

◆ fillDescriptions()

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

static

Definition at line 617 of file PFRecoTauDiscriminationByIsolation.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), submitPVResolutionJobs::desc, reco::tau::RecoTauQualityCuts::fillDescriptions(), ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                     {
   // pfRecoTauDiscriminationByIsolation
   edm::ParameterSetDescription desc;
   desc.add<bool>("storeRawFootprintCorrection", false);
   desc.add<edm::InputTag>("PFTauProducer", edm::InputTag("pfRecoTauProducer"));
   desc.add<bool>("storeRawOccupancy", false);
   desc.add<double>("maximumSumPtCut", 6.0);
 
   edm::ParameterSetDescription desc_qualityCuts;
   reco::tau::RecoTauQualityCuts::fillDescriptions(desc_qualityCuts);
   desc.add<edm::ParameterSetDescription>("qualityCuts", desc_qualityCuts);
 
   desc.add<double>("minTauPtForNoIso", -99.0);
   desc.add<double>("maxAbsPhotonSumPt_outsideSignalCone", 1000000000.0);
   desc.add<edm::InputTag>("vertexSrc", edm::InputTag("offlinePrimaryVertices"));
   desc.add<bool>("applySumPtCut", false);
   desc.add<double>("rhoConeSize", 0.5);
   desc.add<bool>("ApplyDiscriminationByTrackerIsolation", true);
   desc.add<bool>("storeRawPhotonSumPt_outsideSignalCone", false);
   desc.add<edm::InputTag>("rhoProducer", edm::InputTag("fixedGridRhoFastjetAll"));
   desc.add<bool>("enableHGCalWorkaround", false);
 
   {
     edm::ParameterSetDescription vpsd1;
     vpsd1.add<std::string>("selection");
     vpsd1.add<std::string>("offset");
     desc.addVPSet("footprintCorrections", vpsd1, {});
   }
 
   desc.add<std::string>("deltaBetaFactor", "0.38");
   desc.add<bool>("applyFootprintCorrection", false);
   desc.add<bool>("UseAllPFCandsForWeights", false);
   desc.add<double>("relativeSumPtCut", 0.0);
   {
     edm::ParameterSetDescription pset_Prediscriminants;
     pset_Prediscriminants.add<std::string>("BooleanOperator", "and");
     {
       edm::ParameterSetDescription psd1;
       psd1.add<double>("cut");
       psd1.add<edm::InputTag>("Producer");
       pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("leadTrack", psd1);
     }
     {
       // encountered this at
       // RecoTauTag/Configuration/python/HPSPFTaus_cff.py
       // Prediscriminants = requireDecayMode.clone(),
       // requireDecayMode = cms.PSet(
       //     BooleanOperator = cms.string("and"),
       //     decayMode = cms.PSet(
       //         Producer = cms.InputTag('hpsPFTauDiscriminationByDecayModeFindingNewDMs'),
       //         cut = cms.double(0.5)
       //     )
       // )
       edm::ParameterSetDescription psd1;
       psd1.add<double>("cut");
       psd1.add<edm::InputTag>("Producer");
       pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("decayMode", psd1);
     }
     {
       // encountered this at
       // RecoTauTag/Configuration/python/HPSPFTaus_cff.py
       // Prediscriminants = requireDecayMode.clone(),
       // hpsPFTauDiscriminationByLooseIsolation.Prediscriminants.preIso = cms.PSet(
       //     Producer = cms.InputTag("hpsPFTauDiscriminationByLooseChargedIsolation"),
       //     cut = cms.double(0.5)
       // )
       edm::ParameterSetDescription psd1;
       psd1.add<double>("cut");
       psd1.add<edm::InputTag>("Producer");
       pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("preIso", psd1);
     }
     desc.add<edm::ParameterSetDescription>("Prediscriminants", pset_Prediscriminants);
   }
 
   desc.add<unsigned int>("maximumOccupancy", 0);
   desc.add<int>("verbosity", 0);
 
   desc.add<bool>("applyOccupancyCut", true);
   desc.add<bool>("applyDeltaBetaCorrection", false);
   desc.add<bool>("applyRelativeSumPtCut", false);
   desc.add<bool>("storeRawPUsumPt", false);
   desc.add<bool>("applyPhotonPtSumOutsideSignalConeCut", false);
   desc.add<bool>("deltaBetaPUTrackPtCutOverride", false);
   desc.add<bool>("ApplyDiscriminationByWeightedECALIsolation", false);
   desc.add<bool>("storeRawSumPt", false);
   desc.add<bool>("ApplyDiscriminationByECALIsolation", true);
   desc.add<bool>("applyRhoCorrection", false);
 
   desc.add<double>("WeightECALIsolation", 1.0);
   desc.add<double>("rhoUEOffsetCorrection", 1.0);
   desc.add<double>("maxRelPhotonSumPt_outsideSignalCone", 0.1);
   desc.add<double>("deltaBetaPUTrackPtCutOverride_val", -1.5);
   desc.add<double>("isoConeSizeForDeltaBeta", 0.5);
   desc.add<double>("relativeSumPtOffset", 0.0);
   desc.add<double>("customOuterCone", -1.0);
   desc.add<edm::InputTag>("particleFlowSrc", edm::InputTag("particleFlow"));
 
   descriptions.add("pfRecoTauDiscriminationByIsolation", desc);
 }

◆ weightedSum()

double PFRecoTauDiscriminationByIsolation::weightedSum	(	const std::vector< CandidatePtr > &	inColl_,
		double	eta,
		double	phi
	)		const

inline

Definition at line 179 of file PFRecoTauDiscriminationByIsolation.cc.

References reco::deltaR2(), PVValHelper::eta, and MillePedeFileConverter_cfg::out.

                                                                                                   {
     double out = 1.0;
     for (auto const& inObj_ : inColl_) {
       double sum = (inObj_->pt() * inObj_->pt()) / (deltaR2(eta, phi, inObj_->eta(), inObj_->phi()));
       if (sum > 1.0)
         out *= sum;
     }
     return out;
   }

Member Data Documentation

◆ applyDeltaBeta_

bool PFRecoTauDiscriminationByIsolation::applyDeltaBeta_

private

Definition at line 245 of file PFRecoTauDiscriminationByIsolation.cc.

◆ applyFootprintCorrection_

bool PFRecoTauDiscriminationByIsolation::applyFootprintCorrection_

private

Definition at line 223 of file PFRecoTauDiscriminationByIsolation.cc.

◆ applyOccupancyCut_

bool PFRecoTauDiscriminationByIsolation::applyOccupancyCut_

private

Definition at line 208 of file PFRecoTauDiscriminationByIsolation.cc.

◆ applyPhotonPtSumOutsideSignalConeCut_

bool PFRecoTauDiscriminationByIsolation::applyPhotonPtSumOutsideSignalConeCut_

private

Definition at line 219 of file PFRecoTauDiscriminationByIsolation.cc.

◆ applyRelativeSumPtCut_

bool PFRecoTauDiscriminationByIsolation::applyRelativeSumPtCut_

private

Definition at line 212 of file PFRecoTauDiscriminationByIsolation.cc.

◆ applyRhoCorrection_

bool PFRecoTauDiscriminationByIsolation::applyRhoCorrection_

private

Definition at line 258 of file PFRecoTauDiscriminationByIsolation.cc.

◆ applySumPtCut_

bool PFRecoTauDiscriminationByIsolation::applySumPtCut_

private

Definition at line 210 of file PFRecoTauDiscriminationByIsolation.cc.

◆ calculateWeights_

bool PFRecoTauDiscriminationByIsolation::calculateWeights_

private

Definition at line 205 of file PFRecoTauDiscriminationByIsolation.cc.

◆ chargedPFCandidatesInEvent_

std::vector<reco::CandidatePtr> PFRecoTauDiscriminationByIsolation::chargedPFCandidatesInEvent_

private

Definition at line 251 of file PFRecoTauDiscriminationByIsolation.cc.

◆ customIsoCone_

double PFRecoTauDiscriminationByIsolation::customIsoCone_

private

Definition at line 215 of file PFRecoTauDiscriminationByIsolation.cc.

◆ deltaBetaCollectionCone_

double PFRecoTauDiscriminationByIsolation::deltaBetaCollectionCone_

private

Definition at line 253 of file PFRecoTauDiscriminationByIsolation.cc.

◆ deltaBetaFactorThisEvent_

double PFRecoTauDiscriminationByIsolation::deltaBetaFactorThisEvent_

private

Definition at line 255 of file PFRecoTauDiscriminationByIsolation.cc.

◆ deltaBetaFormula_

std::unique_ptr<TFormula> PFRecoTauDiscriminationByIsolation::deltaBetaFormula_

private

Definition at line 254 of file PFRecoTauDiscriminationByIsolation.cc.

◆ enableHGCalWorkaround_

bool PFRecoTauDiscriminationByIsolation::enableHGCalWorkaround_

private

Definition at line 206 of file PFRecoTauDiscriminationByIsolation.cc.

◆ footprintCorrections_

std::vector<std::unique_ptr<FootprintCorrection> > PFRecoTauDiscriminationByIsolation::footprintCorrections_

private

Definition at line 231 of file PFRecoTauDiscriminationByIsolation.cc.

◆ includeGammas_

bool PFRecoTauDiscriminationByIsolation::includeGammas_

private

Definition at line 204 of file PFRecoTauDiscriminationByIsolation.cc.

◆ includeTracks_

bool PFRecoTauDiscriminationByIsolation::includeTracks_

private

Definition at line 203 of file PFRecoTauDiscriminationByIsolation.cc.

◆ maxAbsPhotonSumPt_outsideSignalCone_

double PFRecoTauDiscriminationByIsolation::maxAbsPhotonSumPt_outsideSignalCone_

private

Definition at line 220 of file PFRecoTauDiscriminationByIsolation.cc.

◆ maximumOccupancy_

uint32_t PFRecoTauDiscriminationByIsolation::maximumOccupancy_

private

Definition at line 209 of file PFRecoTauDiscriminationByIsolation.cc.

◆ maximumRelativeSumPt_

double PFRecoTauDiscriminationByIsolation::maximumRelativeSumPt_

private

Definition at line 213 of file PFRecoTauDiscriminationByIsolation.cc.

◆ maximumSumPt_

double PFRecoTauDiscriminationByIsolation::maximumSumPt_

private

Definition at line 211 of file PFRecoTauDiscriminationByIsolation.cc.

◆ maxRelPhotonSumPt_outsideSignalCone_

double PFRecoTauDiscriminationByIsolation::maxRelPhotonSumPt_outsideSignalCone_

private

Definition at line 221 of file PFRecoTauDiscriminationByIsolation.cc.

◆ minPtForNoIso_

double PFRecoTauDiscriminationByIsolation::minPtForNoIso_

private

Definition at line 217 of file PFRecoTauDiscriminationByIsolation.cc.

◆ moduleLabel_

std::string PFRecoTauDiscriminationByIsolation::moduleLabel_

private

Definition at line 192 of file PFRecoTauDiscriminationByIsolation.cc.

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

◆ offsetRelativeSumPt_

double PFRecoTauDiscriminationByIsolation::offsetRelativeSumPt_

private

Definition at line 214 of file PFRecoTauDiscriminationByIsolation.cc.

◆ pfCand_token

edm::EDGetTokenT<edm::View<reco::Candidate> > PFRecoTauDiscriminationByIsolation::pfCand_token

private

Definition at line 247 of file PFRecoTauDiscriminationByIsolation.cc.

◆ pfCandSrc_

edm::InputTag PFRecoTauDiscriminationByIsolation::pfCandSrc_

private

Definition at line 246 of file PFRecoTauDiscriminationByIsolation.cc.

◆ pileupQcutsGeneralQCuts_

std::unique_ptr<tau::RecoTauQualityCuts> PFRecoTauDiscriminationByIsolation::pileupQcutsGeneralQCuts_

private

Definition at line 199 of file PFRecoTauDiscriminationByIsolation.cc.

◆ pileupQcutsPUTrackSelection_

std::unique_ptr<tau::RecoTauQualityCuts> PFRecoTauDiscriminationByIsolation::pileupQcutsPUTrackSelection_

private

Definition at line 198 of file PFRecoTauDiscriminationByIsolation.cc.

◆ qcuts_

std::unique_ptr<tau::RecoTauQualityCuts> PFRecoTauDiscriminationByIsolation::qcuts_

private

Definition at line 195 of file PFRecoTauDiscriminationByIsolation.cc.

◆ qualityCutsPSet_

edm::ParameterSet PFRecoTauDiscriminationByIsolation::qualityCutsPSet_

private

Definition at line 194 of file PFRecoTauDiscriminationByIsolation.cc.

◆ rho_token

edm::EDGetTokenT<double> PFRecoTauDiscriminationByIsolation::rho_token

private

Definition at line 261 of file PFRecoTauDiscriminationByIsolation.cc.

◆ rhoConeSize_

double PFRecoTauDiscriminationByIsolation::rhoConeSize_

private

Definition at line 262 of file PFRecoTauDiscriminationByIsolation.cc.

◆ rhoCorrectionThisEvent_

double PFRecoTauDiscriminationByIsolation::rhoCorrectionThisEvent_

private

Definition at line 264 of file PFRecoTauDiscriminationByIsolation.cc.

◆ rhoProducer_

edm::InputTag PFRecoTauDiscriminationByIsolation::rhoProducer_

private

Definition at line 260 of file PFRecoTauDiscriminationByIsolation.cc.

◆ rhoThisEvent_

double PFRecoTauDiscriminationByIsolation::rhoThisEvent_

private

Definition at line 265 of file PFRecoTauDiscriminationByIsolation.cc.

◆ rhoUEOffsetCorrection_

double PFRecoTauDiscriminationByIsolation::rhoUEOffsetCorrection_

private

Definition at line 263 of file PFRecoTauDiscriminationByIsolation.cc.

◆ storeRawFootprintCorrection_

bool PFRecoTauDiscriminationByIsolation::storeRawFootprintCorrection_

private

Definition at line 237 of file PFRecoTauDiscriminationByIsolation.cc.

◆ storeRawOccupancy_

bool PFRecoTauDiscriminationByIsolation::storeRawOccupancy_

private

Definition at line 234 of file PFRecoTauDiscriminationByIsolation.cc.

◆ storeRawPhotonSumPt_outsideSignalCone_

bool PFRecoTauDiscriminationByIsolation::storeRawPhotonSumPt_outsideSignalCone_

private

Definition at line 238 of file PFRecoTauDiscriminationByIsolation.cc.

◆ storeRawPUsumPt_

bool PFRecoTauDiscriminationByIsolation::storeRawPUsumPt_

private

Definition at line 236 of file PFRecoTauDiscriminationByIsolation.cc.

◆ storeRawSumPt_

bool PFRecoTauDiscriminationByIsolation::storeRawSumPt_

private

Definition at line 235 of file PFRecoTauDiscriminationByIsolation.cc.

◆ useAllPFCands_

bool PFRecoTauDiscriminationByIsolation::useAllPFCands_

private

Definition at line 259 of file PFRecoTauDiscriminationByIsolation.cc.

◆ verbosity_

int PFRecoTauDiscriminationByIsolation::verbosity_

private

Definition at line 268 of file PFRecoTauDiscriminationByIsolation.cc.

◆ vertex_token

edm::EDGetTokenT<reco::VertexCollection> PFRecoTauDiscriminationByIsolation::vertex_token

private

Definition at line 250 of file PFRecoTauDiscriminationByIsolation.cc.

◆ vertexAssociator_

std::unique_ptr<tau::RecoTauVertexAssociator> PFRecoTauDiscriminationByIsolation::vertexAssociator_

private

Definition at line 201 of file PFRecoTauDiscriminationByIsolation.cc.

◆ vertexSrc_

edm::InputTag PFRecoTauDiscriminationByIsolation::vertexSrc_

private

Definition at line 249 of file PFRecoTauDiscriminationByIsolation.cc.

◆ weightGammas_

double PFRecoTauDiscriminationByIsolation::weightGammas_

private

Definition at line 207 of file PFRecoTauDiscriminationByIsolation.cc.

Classes

Public Member Functions

Static Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PFRecoTauDiscriminationByIsolation()

◆ ~PFRecoTauDiscriminationByIsolation()

Member Function Documentation

◆ beginEvent()

◆ discriminate()

◆ fillDescriptions()

◆ weightedSum()

Member Data Documentation

◆ applyDeltaBeta_

◆ applyFootprintCorrection_

◆ applyOccupancyCut_

◆ applyPhotonPtSumOutsideSignalConeCut_

◆ applyRelativeSumPtCut_

◆ applyRhoCorrection_

◆ applySumPtCut_

◆ calculateWeights_

◆ chargedPFCandidatesInEvent_

◆ customIsoCone_

◆ deltaBetaCollectionCone_

◆ deltaBetaFactorThisEvent_

◆ deltaBetaFormula_

◆ enableHGCalWorkaround_

◆ footprintCorrections_

◆ includeGammas_

◆ includeTracks_

◆ maxAbsPhotonSumPt_outsideSignalCone_

◆ maximumOccupancy_

◆ maximumRelativeSumPt_

◆ maximumSumPt_

◆ maxRelPhotonSumPt_outsideSignalCone_

◆ minPtForNoIso_

◆ moduleLabel_

◆ offsetRelativeSumPt_

◆ pfCand_token

◆ pfCandSrc_

◆ pileupQcutsGeneralQCuts_

◆ pileupQcutsPUTrackSelection_

◆ qcuts_

◆ qualityCutsPSet_

◆ rho_token

◆ rhoConeSize_

◆ rhoCorrectionThisEvent_

◆ rhoProducer_

◆ rhoThisEvent_

◆ rhoUEOffsetCorrection_

◆ storeRawFootprintCorrection_

◆ storeRawOccupancy_

◆ storeRawPhotonSumPt_outsideSignalCone_

◆ storeRawPUsumPt_

◆ storeRawSumPt_

◆ useAllPFCands_

◆ verbosity_

◆ vertex_token

◆ vertexAssociator_

◆ vertexSrc_

◆ weightGammas_