Inheritance diagram for PFRecoTauDiscriminationByIsolationContainer:

Classes
struct	FootprintCorrection

Public Types
enum	StoredRawType { None, SumPt, PUsumPt, Occupancy, FootPrintCorrection, PhotonSumPt }

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<>
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
void	beginEvent (const edm::Event &evt, const edm::EventSetup &evtSetup) override

reco::SingleTauDiscriminatorContainer	discriminate (const PFTauRef &pfTau) const override

	PFRecoTauDiscriminationByIsolationContainer (const edm::ParameterSet &pset)

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

	~PFRecoTauDiscriminationByIsolationContainer () 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 ()

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	~TauDiscriminationProducerBase () 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)

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
std::vector< bool >	applyDeltaBetaCorrection_

bool	applyFootprintCorrection_

bool	applyRhoCorrection_

std::vector< bool >	calculateWeights_

std::vector< reco::CandidatePtr >	chargedPFCandidatesInEvent_

double	customIsoCone_

double	deltaBetaCollectionCone_

double	deltaBetaFactorThisEvent_

std::unique_ptr< TFormula >	deltaBetaFormula_

bool	deltaBetaNeeded_

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

bool	gammasNeeded_

std::vector< bool >	includeGammas_

std::vector< bool >	includeTracks_

std::vector< std::vector< double > >	maxAbsValue_

std::vector< std::vector< double > >	maxRelValue_

double	minPtForNoIso_

std::string	moduleLabel_

std::vector< std::vector< double > >	offsetRelValue_

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_

std::vector< std::vector< int > >	rawValue_reference_

edm::EDGetTokenT< double >	rho_token

double	rhoConeSize_

double	rhoCorrectionThisEvent_

edm::InputTag	rhoProducer_

double	rhoThisEvent_

double	rhoUEOffsetCorrection_

std::vector< StoredRawType >	storeRawValue_

bool	tracksNeeded_

std::vector< bool >	useAllPFCandsForWeights_

int	verbosity_

edm::EDGetTokenT< reco::VertexCollection >	vertex_token

std::unique_ptr< tau::RecoTauVertexAssociator >	vertexAssociator_

edm::InputTag	vertexSrc_

double	weightGammas_

bool	weightsNeeded_

Additional Inherited Members
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 28 of file PFRecoTauDiscriminationByIsolationContainer.cc.

Member Enumeration Documentation

◆ StoredRawType

enum PFRecoTauDiscriminationByIsolationContainer::StoredRawType

Enumerator
None
SumPt
PUsumPt
Occupancy
FootPrintCorrection
PhotonSumPt

Definition at line 30 of file PFRecoTauDiscriminationByIsolationContainer.cc.

30 { None, SumPt, PUsumPt, Occupancy, FootPrintCorrection, PhotonSumPt };

Constructor & Destructor Documentation

◆ PFRecoTauDiscriminationByIsolationContainer()

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

inlineexplicit

Definition at line 31 of file PFRecoTauDiscriminationByIsolationContainer.cc.

       : PFTauDiscriminationContainerProducerBase(pset),
         moduleLabel_(pset.getParameter<std::string>("@module_label")),
         qualityCutsPSet_(pset.getParameter<edm::ParameterSet>("qualityCuts")) {
     // 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");
  
     // Get configs for raw values
     bool storeRawFootprintCorrection = false;
     deltaBetaNeeded_ = false;
     weightsNeeded_ = false;
     tracksNeeded_ = false;
     gammasNeeded_ = false;
     storeRawValue_.clear();
     auto const& rawDefs = pset.getParameter<std::vector<edm::ParameterSet>>("IDdefinitions");
     std::vector<std::string> idnames;
     for (auto const& rawDefsEntry : rawDefs) {
       idnames.push_back(rawDefsEntry.getParameter<std::string>("IDname"));
       // Can only store one type
       int numStoreOptions = 0;
       if (rawDefsEntry.getParameter<bool>("storeRawSumPt")) {
         storeRawValue_.push_back(SumPt);
         ++numStoreOptions;
       }
       if (rawDefsEntry.getParameter<bool>("storeRawOccupancy")) {
         storeRawValue_.push_back(Occupancy);
         ++numStoreOptions;
       }
       if (rawDefsEntry.getParameter<bool>("storeRawPUsumPt")) {
         storeRawValue_.push_back(PUsumPt);
         ++numStoreOptions;
       }
       if (rawDefsEntry.getParameter<bool>("storeRawFootprintCorrection")) {
         storeRawValue_.push_back(FootPrintCorrection);
         storeRawFootprintCorrection = true;
         ++numStoreOptions;
       }
       if (rawDefsEntry.getParameter<bool>("storeRawPhotonSumPt_outsideSignalCone")) {
         storeRawValue_.push_back(PhotonSumPt);
         ++numStoreOptions;
       }
       if (numStoreOptions != 1) {
         throw cms::Exception("BadIsoConfig")
             << "Multiple or none of 'store sum pt' and/or 'store occupancy' options are set."
             << " These options are mutually exclusive.";
       }
  
       includeGammas_.push_back(rawDefsEntry.getParameter<bool>("ApplyDiscriminationByECALIsolation"));
       if (includeGammas_.back())
         gammasNeeded_ = true;
       calculateWeights_.push_back(rawDefsEntry.getParameter<bool>("ApplyDiscriminationByWeightedECALIsolation"));
       if (calculateWeights_.back())
         weightsNeeded_ = true;
       includeTracks_.push_back(rawDefsEntry.getParameter<bool>("ApplyDiscriminationByTrackerIsolation"));
       if (includeTracks_.back())
         tracksNeeded_ = true;
       applyDeltaBetaCorrection_.push_back(rawDefsEntry.getParameter<bool>("applyDeltaBetaCorrection"));
       if (applyDeltaBetaCorrection_.back())
         deltaBetaNeeded_ = true;
       useAllPFCandsForWeights_.push_back(rawDefsEntry.getParameter<bool>("UseAllPFCandsForWeights"));
  
       // sanity check2 - can't use weighted and unweighted iso at the same time
       if (includeGammas_.back() && calculateWeights_.back()) {
         throw cms::Exception("BadIsoConfig")
             << "Both 'ApplyDiscriminationByECALIsolation' and 'ApplyDiscriminationByWeightedECALIsolation' "
             << "have been set to true. These options are mutually exclusive.";
       }
     }
  
     // Get configs for WPs - negative cut values are used to switch of the condition
     std::vector<edm::ParameterSet> wpDefs = pset.getParameter<std::vector<edm::ParameterSet>>("IDWPdefinitions");
     for (std::vector<edm::ParameterSet>::iterator wpDefsEntry = wpDefs.begin(); wpDefsEntry != wpDefs.end();
          ++wpDefsEntry) {
       maxAbsValue_.push_back(wpDefsEntry->getParameter<std::vector<double>>("maximumAbsoluteValues"));
       maxRelValue_.push_back(wpDefsEntry->getParameter<std::vector<double>>("maximumRelativeValues"));
       offsetRelValue_.push_back(wpDefsEntry->getParameter<std::vector<double>>("relativeValueOffsets"));
       auto refRawIDNames = wpDefsEntry->getParameter<std::vector<std::string>>("referenceRawIDNames");
       if (!maxAbsValue_.back().empty() && maxAbsValue_.back().size() != refRawIDNames.size())
         throw cms::Exception("BadIsoConfig")
             << "WP configuration: Length of 'maximumAbsoluteValues' does not match length of 'referenceRawIDNames'!";
       if (!maxRelValue_.back().empty() && maxRelValue_.back().size() != refRawIDNames.size())
         throw cms::Exception("BadIsoConfig")
             << "WP configuration: Length of 'maximumRelativeValues' does not match length of 'referenceRawIDNames'!";
       if (!offsetRelValue_.back().empty() && offsetRelValue_.back().size() != refRawIDNames.size())
         throw cms::Exception("BadIsoConfig")
             << "WP configuration: Length of 'relativeValueOffsets' does not match length of 'referenceRawIDNames'!";
       else if (offsetRelValue_.back().empty())
         offsetRelValue_.back().assign(refRawIDNames.size(), 0.0);
       rawValue_reference_.push_back(std::vector<int>(refRawIDNames.size()));
       for (size_t i = 0; i < refRawIDNames.size(); i++) {
         bool found = false;
         for (size_t j = 0; j < idnames.size(); j++) {
           if (refRawIDNames[i] == idnames[j]) {
             rawValue_reference_.back()[i] = j;
             found = true;
             break;
           }
         }
         if (!found)
           throw cms::Exception("BadIsoConfig")
               << "WP configuration: Requested raw ID '" << refRawIDNames[i] << "' not defined!";
       }
     }
  
     customIsoCone_ = pset.getParameter<double>("customOuterCone");
  
     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_.reset(new tau::RecoTauQualityCuts(isolationQCuts));
  
     vertexAssociator_.reset(new tau::RecoTauVertexAssociator(qualityCutsPSet_, consumesCollector()));
  
     if (deltaBetaNeeded_ || weightsNeeded_) {
       // 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_.reset(new tau::RecoTauQualityCuts(puFactorizedIsoQCuts.first));
  
       pileupQcutsGeneralQCuts_.reset(new 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_.reset(new 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");
     }
  
     verbosity_ = pset.getParameter<int>("verbosity");
   }

References HLT_2018_cff::deltaBetaPUTrackPtCutOverride, HLT_2018_cff::deltaBetaPUTrackPtCutOverride_val, Exception, reco::tau::factorizePUQCuts(), newFWLiteAna::found, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), mps_fire::i, dqmiolumiharvest::j, eostools::move(), IntegrityClient_cfi::Occupancy, hltrates_dqm_sourceclient-live_cfg::offset, muonDTDigis_cfi::pset, corrVsCorr::selection, HLT_2018_cff::storeRawFootprintCorrection, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~PFRecoTauDiscriminationByIsolationContainer()

PFRecoTauDiscriminationByIsolationContainer::~PFRecoTauDiscriminationByIsolationContainer ( )

inlineoverride

Definition at line 205 of file PFRecoTauDiscriminationByIsolationContainer.cc.

205 {}

Member Function Documentation

◆ beginEvent()

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

overridevirtual

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

Definition at line 296 of file PFRecoTauDiscriminationByIsolationContainer.cc.

                                                                                               {
   // 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 (deltaBetaNeeded_ || weightsNeeded_) {
     // 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_;
   }
 }

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

◆ discriminate()

reco::SingleTauDiscriminatorContainer PFRecoTauDiscriminationByIsolationContainer::discriminate ( const PFTauRef & pfTau ) const

override

Definition at line 334 of file PFRecoTauDiscriminationByIsolationContainer.cc.

                                  {
   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_;
   std::vector<CandidatePtr> isoPUall_;
   CandidateCollection isoNeutralWeight_;
   CandidateCollection isoNeutralWeight_UseAllPFCands_;
   std::vector<CandidatePtr> chPV_;
   std::vector<CandidatePtr> chPVall_;
   isoCharged_.reserve(pfTau->isolationChargedHadrCands().size());
   isoNeutral_.reserve(pfTau->isolationGammaCands().size());
   isoPU_.reserve(std::min(100UL, chargedPFCandidatesInEvent_.size()));
   isoPUall_.reserve(std::min(100UL, chargedPFCandidatesInEvent_.size()));
   isoNeutralWeight_.reserve(pfTau->isolationGammaCands().size());
   isoNeutralWeight_UseAllPFCands_.reserve(pfTau->isolationGammaCands().size());
  
   chPV_.reserve(std::min(50UL, chargedPFCandidatesInEvent_.size()));
   chPVall_.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 (deltaBetaNeeded_ || weightsNeeded_) {
     pileupQcutsGeneralQCuts_->setPV(pv);
     pileupQcutsGeneralQCuts_->setLeadTrack(*pfTau->leadChargedHadrCand());
     pileupQcutsPUTrackSelection_->setPV(pv);
     pileupQcutsPUTrackSelection_->setLeadTrack(*pfTau->leadChargedHadrCand());
   }
  
   // Load the tracks if they are being used.
   if (tracksNeeded_) {
     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 (gammasNeeded_ || weightsNeeded_) {
     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 (deltaBetaNeeded_ || weightsNeeded_) {
     // 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
     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();
     isoPUall_ = std::move(allPU);
     chPVall_ = std::move(allNPU);
   }
  
   if (weightsNeeded_) {
     for (auto const& isoObject : isoNeutral_) {
       if (isoObject->charge() != 0) {
         // weight only neutral objects
         isoNeutralWeight_.push_back(*isoObject);
         isoNeutralWeight_UseAllPFCands_.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);
       }
       {
         double sumNPU = 0.5 * log(weightedSum(chPVall_, eta, phi));
  
         double sumPU = 0.5 * log(weightedSum(isoPUall_, eta, phi));
         LeafCandidate neutral(*isoObject);
         if ((sumNPU + sumPU) > 0)
           neutral.setP4(((sumNPU) / (sumNPU + sumPU)) * neutral.p4());
  
         isoNeutralWeight_UseAllPFCands_.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;
     // Remove all the objects not in our iso cone
     for (auto const& isoObject : isoCharged_) {
       if (filter(isoObject))
         isoCharged_filter.push_back(isoObject);
     }
     isoCharged_ = isoCharged_filter;
     for (auto const& isoObject : isoNeutral_) {
       if (filter(isoObject))
         isoNeutral_filter.push_back(isoObject);
     }
     isoNeutral_ = isoNeutral_filter;
     {
       CandidateCollection isoNeutralWeight_filter;
       for (auto const& isoObject : isoNeutralWeight_) {
         if (filter2(isoObject))
           isoNeutralWeight_filter.push_back(isoObject);
       }
       isoNeutralWeight_ = isoNeutralWeight_filter;
     }
     {
       CandidateCollection isoNeutralWeight_filter;
       for (auto const& isoObject : isoNeutralWeight_UseAllPFCands_) {
         if (filter2(isoObject))
           isoNeutralWeight_filter.push_back(isoObject);
       }
       isoNeutralWeight_UseAllPFCands_ = isoNeutralWeight_filter;
     }
   }
  
   //Now all needed incredients are ready. Loop over all ID configurations and produce output
   reco::SingleTauDiscriminatorContainer result;
   for (size_t i = 0; i < includeGammas_.size(); i++) {
     //--- nObjects requirement
     int neutrals = isoNeutral_.size();
  
     if (applyDeltaBetaCorrection_.at(i)) {
       neutrals -= TMath::Nint(deltaBetaFactorThisEvent_ * isoPU_.size());
     }
     if (neutrals < 0) {
       neutrals = 0;
     }
  
     int nOccupants = isoCharged_.size() + neutrals;
  
     double footprintCorrection_value = 0.;
     if (applyFootprintCorrection_ || storeRawValue_.at(i) == FootPrintCorrection) {
       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 (storeRawValue_.at(i) == SumPt || storeRawValue_.at(i) == PUsumPt) {
       double chargedPt = 0.;
       double neutralPt = 0.;
       double weightedNeutralPt = 0.;
       if (includeTracks_.at(i)) {
         for (auto const& isoObject : isoCharged_) {
           chargedPt += isoObject->pt();
         }
       }
  
       if (calculateWeights_.at(i)) {
         if (useAllPFCandsForWeights_.at(i)) {
           for (auto const& isoObject : isoNeutralWeight_UseAllPFCands_) {
             weightedNeutralPt += isoObject.pt();
           }
         } else {
           for (auto const& isoObject : isoNeutralWeight_) {
             weightedNeutralPt += isoObject.pt();
           }
         }
       } else if (includeGammas_.at(i)) {
         for (auto const& isoObject : isoNeutral_) {
           neutralPt += 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_.at(i)) {
         neutralPt = weightedNeutralPt;
       }
  
       if (applyDeltaBetaCorrection_.at(i)) {
         neutralPt -= (deltaBetaFactorThisEvent_ * puPt);
       }
  
       if (applyFootprintCorrection_) {
         neutralPt -= footprintCorrection_value;
       }
  
       if (applyRhoCorrection_) {
         neutralPt -= rhoThisEvent_;
       }
  
       if (neutralPt < 0.) {
         neutralPt = 0.;
       }
  
       totalPt = chargedPt + weightGammas_ * neutralPt;
     }
  
     double photonSumPt_outsideSignalCone = 0.;
     if (storeRawValue_.at(i) == PhotonSumPt) {
       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();
       }
     }
  
     // We did error checking in the constructor, so this is safe.
     if (storeRawValue_.at(i) == SumPt) {
       result.rawValues.push_back(totalPt);
     } else if (storeRawValue_.at(i) == PUsumPt) {
       if (applyDeltaBetaCorrection_.at(i))
         result.rawValues.push_back(puPt);
       else if (applyRhoCorrection_)
         result.rawValues.push_back(rhoThisEvent_);
       else
         result.rawValues.push_back(0.);
     } else if (storeRawValue_.at(i) == Occupancy) {
       result.rawValues.push_back(nOccupants);
     } else if (storeRawValue_.at(i) == FootPrintCorrection) {
       result.rawValues.push_back(footprintCorrection_value);
     } else if (storeRawValue_.at(i) == PhotonSumPt) {
       result.rawValues.push_back(photonSumPt_outsideSignalCone);
     }
   }
   for (size_t i = 0; i < rawValue_reference_.size(); i++) {
     bool pass = true;
     if (minPtForNoIso_ > 0. && pfTau->pt() > minPtForNoIso_)
       LogDebug("discriminate") << "tau pt = " << pfTau->pt() << "\t  min cutoff pt = " << minPtForNoIso_;
     else {
       for (size_t j = 0; j < rawValue_reference_[i].size(); j++) {
         double rawValue = result.rawValues[rawValue_reference_[i][j]];
         LogTrace("discriminate") << "Iso sum = " << rawValue << " (max_abs = " << maxAbsValue_[i][j]
                                  << ", max_rel = " << maxRelValue_[i][j] << ", offset_rel = " << offsetRelValue_[i][j]
                                  << ")";
         if (!maxAbsValue_[i].empty() && maxAbsValue_[i][j] >= 0.0)
           pass = rawValue <= maxAbsValue_[i][j];
         if (!maxRelValue_[i].empty() && maxRelValue_[i][j] >= 0.0)
           pass = rawValue <= maxRelValue_[i][j] * (pfTau->pt() - offsetRelValue_[i][j]);
         if (!pass)
           break;  // do not pass if one of the conditions in the j list fails
       }
     }
     result.workingPoints.push_back(pass);
   }
   return result;
 }

References gather_cfg::cout, reco::deltaR(), HGC3DClusterGenMatchSelector_cfi::dR, relativeConstraints::empty, PVValHelper::eta, ALCARECOTkAlBeamHalo_cff::filter, mps_fire::i, edm::Ref< C, T, F >::isNonnull(), dqmiolumiharvest::j, dqm-mbProfile::log, LogDebug, LogTrace, min(), eostools::move(), IntegrityClient_cfi::Occupancy, reco::LeafCandidate::p4(), edm::OwnVector< T, P >::push_back(), MetAnalyzer::pv(), edm::OwnVector< T, P >::reserve(), mps_fire::result, and reco::LeafCandidate::setP4().

◆ fillDescriptions()

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

static

Definition at line 658 of file PFRecoTauDiscriminationByIsolationContainer.cc.

                                                                                                              {
   // pfRecoTauDiscriminationByIsolationContainer
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("PFTauProducer", edm::InputTag("pfRecoTauProducer"));
  
   {
     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.add<edm::ParameterSetDescription>("qualityCuts", pset_qualityCuts);
   }
  
   desc.add<double>("minTauPtForNoIso", -99.0);
   desc.add<edm::InputTag>("vertexSrc", edm::InputTag("offlinePrimaryVertices"));
   desc.add<double>("rhoConeSize", 0.5);
   desc.add<edm::InputTag>("rhoProducer", edm::InputTag("fixedGridRhoFastjetAll"));
  
   {
     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);
   {
     edm::ParameterSetDescription pset_Prediscriminants;
     pset_Prediscriminants.add<std::string>("BooleanOperator", "and");
     {
       edm::ParameterSetDescription psd1;
       psd1.add<double>("cut", 0.5);
       psd1.add<edm::InputTag>("Producer", edm::InputTag("pfRecoTauDiscriminationByLeadingTrackFinding"));
       pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("leadTrack", psd1);
     }
     {
       edm::ParameterSetDescription psd1;
       psd1.add<double>("cut", 0.5);
       psd1.add<edm::InputTag>("Producer", edm::InputTag("hpsPFTauDiscriminationByDecayModeFindingNewDMs"));
       pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("decayMode", psd1);
     }
     {
       edm::ParameterSetDescription psd1;
       psd1.add<double>("cut", 0.5);
       psd1.add<edm::InputTag>("Producer", edm::InputTag("hpsPFTauDiscriminationByLooseChargedIsolation"));
       pset_Prediscriminants.addOptional<edm::ParameterSetDescription>("preIso", psd1);
     }
     desc.add<edm::ParameterSetDescription>("Prediscriminants", pset_Prediscriminants);
   }
  
   desc.add<int>("verbosity", 0);
  
   desc.add<bool>("deltaBetaPUTrackPtCutOverride", false);
   desc.add<bool>("applyRhoCorrection", false);
  
   desc.add<double>("WeightECALIsolation", 1.0);
   desc.add<double>("rhoUEOffsetCorrection", 1.0);
   desc.add<double>("deltaBetaPUTrackPtCutOverride_val", -1.5);
   desc.add<double>("isoConeSizeForDeltaBeta", 0.5);
   desc.add<double>("customOuterCone", -1.0);
   desc.add<edm::InputTag>("particleFlowSrc", edm::InputTag("particleFlow"));
  
   // options for various stored ID raw values
   edm::ParameterSetDescription desc_idlist;
   desc_idlist.add<string>("IDname");  //not needed by producer but required for mapping at PAT level
   desc_idlist.add<bool>("storeRawSumPt", false);
   desc_idlist.add<bool>("storeRawPUsumPt", false);
   desc_idlist.add<bool>("storeRawOccupancy", false);
   desc_idlist.add<bool>("storeRawFootprintCorrection", false);
   desc_idlist.add<bool>("storeRawPhotonSumPt_outsideSignalCone", false);
   desc_idlist.add<bool>("ApplyDiscriminationByECALIsolation", false);
   desc_idlist.add<bool>("ApplyDiscriminationByWeightedECALIsolation", false);
   desc_idlist.add<bool>("ApplyDiscriminationByTrackerIsolation", false);
   desc_idlist.add<bool>("applyDeltaBetaCorrection", false);
   desc_idlist.add<bool>("UseAllPFCandsForWeights", false);
   desc.addVPSet("IDdefinitions", desc_idlist, {});
   // options for various stored ID WPs
   edm::ParameterSetDescription desc_idwplist;
   desc_idwplist.add<string>("IDname");  //not needed by producer but required for mapping at PAT level
   desc_idwplist.add<std::vector<string>>("referenceRawIDNames")
       ->setComment(
           "List of raw IDs defined in 'IDdefinitions' to pass all respective conditions defined in "
           "'maximumAbsoluteValues', 'maximumRelativeValues' , and 'relativeValueOffsets'");
   desc_idwplist.add<std::vector<double>>("maximumAbsoluteValues", {});
   desc_idwplist.add<std::vector<double>>("maximumRelativeValues", {});
   desc_idwplist.add<std::vector<double>>("relativeValueOffsets", {});
   desc.addVPSet("IDWPdefinitions", desc_idwplist, {});
  
   descriptions.add("pfRecoTauDiscriminationByIsolationContainer", desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptional(), edm::ParameterSetDescription::addVPSet(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ weightedSum()

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

inline

Definition at line 210 of file PFRecoTauDiscriminationByIsolationContainer.cc.

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

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

Member Data Documentation

◆ applyDeltaBetaCorrection_

std::vector<bool> PFRecoTauDiscriminationByIsolationContainer::applyDeltaBetaCorrection_

private

Definition at line 263 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ applyFootprintCorrection_

bool PFRecoTauDiscriminationByIsolationContainer::applyFootprintCorrection_

private

Definition at line 242 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ applyRhoCorrection_

bool PFRecoTauDiscriminationByIsolationContainer::applyRhoCorrection_

private

Definition at line 284 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ calculateWeights_

std::vector<bool> PFRecoTauDiscriminationByIsolationContainer::calculateWeights_

private

Definition at line 261 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ chargedPFCandidatesInEvent_

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

private

Definition at line 277 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ customIsoCone_

double PFRecoTauDiscriminationByIsolationContainer::customIsoCone_

private

Definition at line 238 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ deltaBetaCollectionCone_

double PFRecoTauDiscriminationByIsolationContainer::deltaBetaCollectionCone_

private

Definition at line 279 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ deltaBetaFactorThisEvent_

double PFRecoTauDiscriminationByIsolationContainer::deltaBetaFactorThisEvent_

private

Definition at line 281 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ deltaBetaFormula_

std::unique_ptr<TFormula> PFRecoTauDiscriminationByIsolationContainer::deltaBetaFormula_

private

Definition at line 280 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ deltaBetaNeeded_

bool PFRecoTauDiscriminationByIsolationContainer::deltaBetaNeeded_

private

Definition at line 271 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ footprintCorrections_

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

private

Definition at line 250 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ gammasNeeded_

bool PFRecoTauDiscriminationByIsolationContainer::gammasNeeded_

private

Definition at line 236 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ includeGammas_

std::vector<bool> PFRecoTauDiscriminationByIsolationContainer::includeGammas_

private

Definition at line 260 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ includeTracks_

std::vector<bool> PFRecoTauDiscriminationByIsolationContainer::includeTracks_

private

Definition at line 262 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ maxAbsValue_

std::vector<std::vector<double> > PFRecoTauDiscriminationByIsolationContainer::maxAbsValue_

private

Definition at line 256 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ maxRelValue_

std::vector<std::vector<double> > PFRecoTauDiscriminationByIsolationContainer::maxRelValue_

private

Definition at line 257 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ minPtForNoIso_

double PFRecoTauDiscriminationByIsolationContainer::minPtForNoIso_

private

Definition at line 240 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ moduleLabel_

std::string PFRecoTauDiscriminationByIsolationContainer::moduleLabel_

private

Definition at line 223 of file PFRecoTauDiscriminationByIsolationContainer.cc.

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

◆ offsetRelValue_

std::vector<std::vector<double> > PFRecoTauDiscriminationByIsolationContainer::offsetRelValue_

private

Definition at line 258 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ pfCand_token

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

private

Definition at line 273 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ pfCandSrc_

edm::InputTag PFRecoTauDiscriminationByIsolationContainer::pfCandSrc_

private

Definition at line 272 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ pileupQcutsGeneralQCuts_

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

private

Definition at line 230 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ pileupQcutsPUTrackSelection_

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

private

Definition at line 229 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ qcuts_

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

private

Definition at line 226 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ qualityCutsPSet_

edm::ParameterSet PFRecoTauDiscriminationByIsolationContainer::qualityCutsPSet_

private

Definition at line 225 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ rawValue_reference_

std::vector<std::vector<int> > PFRecoTauDiscriminationByIsolationContainer::rawValue_reference_

private

Definition at line 255 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ rho_token

edm::EDGetTokenT<double> PFRecoTauDiscriminationByIsolationContainer::rho_token

private

Definition at line 286 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ rhoConeSize_

double PFRecoTauDiscriminationByIsolationContainer::rhoConeSize_

private

Definition at line 287 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ rhoCorrectionThisEvent_

double PFRecoTauDiscriminationByIsolationContainer::rhoCorrectionThisEvent_

private

Definition at line 289 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ rhoProducer_

edm::InputTag PFRecoTauDiscriminationByIsolationContainer::rhoProducer_

private

Definition at line 285 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ rhoThisEvent_

double PFRecoTauDiscriminationByIsolationContainer::rhoThisEvent_

private

Definition at line 290 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ rhoUEOffsetCorrection_

double PFRecoTauDiscriminationByIsolationContainer::rhoUEOffsetCorrection_

private

Definition at line 288 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ storeRawValue_

std::vector<StoredRawType> PFRecoTauDiscriminationByIsolationContainer::storeRawValue_

private

Definition at line 253 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ tracksNeeded_

bool PFRecoTauDiscriminationByIsolationContainer::tracksNeeded_

private

Definition at line 235 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ useAllPFCandsForWeights_

std::vector<bool> PFRecoTauDiscriminationByIsolationContainer::useAllPFCandsForWeights_

private

Definition at line 264 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ verbosity_

int PFRecoTauDiscriminationByIsolationContainer::verbosity_

private

Definition at line 293 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ vertex_token

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

private

Definition at line 276 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ vertexAssociator_

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

private

Definition at line 232 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ vertexSrc_

edm::InputTag PFRecoTauDiscriminationByIsolationContainer::vertexSrc_

private

Definition at line 275 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ weightGammas_

double PFRecoTauDiscriminationByIsolationContainer::weightGammas_

private

Definition at line 237 of file PFRecoTauDiscriminationByIsolationContainer.cc.

◆ weightsNeeded_

bool PFRecoTauDiscriminationByIsolationContainer::weightsNeeded_

private

Definition at line 234 of file PFRecoTauDiscriminationByIsolationContainer.cc.

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ StoredRawType

Constructor & Destructor Documentation

◆ PFRecoTauDiscriminationByIsolationContainer()

◆ ~PFRecoTauDiscriminationByIsolationContainer()

Member Function Documentation

◆ beginEvent()

◆ discriminate()

◆ fillDescriptions()

◆ weightedSum()

Member Data Documentation

◆ applyDeltaBetaCorrection_

◆ applyFootprintCorrection_

◆ applyRhoCorrection_

◆ calculateWeights_

◆ chargedPFCandidatesInEvent_

◆ customIsoCone_

◆ deltaBetaCollectionCone_

◆ deltaBetaFactorThisEvent_

◆ deltaBetaFormula_

◆ deltaBetaNeeded_

◆ footprintCorrections_

◆ gammasNeeded_

◆ includeGammas_

◆ includeTracks_

◆ maxAbsValue_

◆ maxRelValue_

◆ minPtForNoIso_

◆ moduleLabel_

◆ offsetRelValue_

◆ pfCand_token

◆ pfCandSrc_

◆ pileupQcutsGeneralQCuts_

◆ pileupQcutsPUTrackSelection_

◆ qcuts_

◆ qualityCutsPSet_

◆ rawValue_reference_

◆ rho_token

◆ rhoConeSize_

◆ rhoCorrectionThisEvent_

◆ rhoProducer_

◆ rhoThisEvent_

◆ rhoUEOffsetCorrection_

◆ storeRawValue_

◆ tracksNeeded_

◆ useAllPFCandsForWeights_

◆ verbosity_

◆ vertex_token

◆ vertexAssociator_

◆ vertexSrc_

◆ weightGammas_

◆ weightsNeeded_