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< PFCandidatePtr > &inColl_, double eta, double phi) const

	~PFRecoTauDiscriminationByIsolation () override

Public Member Functions inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
virtual double	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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Private Attributes
bool	applyDeltaBeta_

bool	applyFootprintCorrection_

bool	applyOccupancyCut_

bool	applyPhotonPtSumOutsideSignalConeCut_

bool	applyRelativeSumPtCut_

bool	applyRhoCorrection_

bool	applySumPtCut_

bool	calculateWeights_

std::vector< reco::PFCandidatePtr >	chargedPFCandidatesInEvent_

double	customIsoCone_

double	deltaBetaCollectionCone_

double	deltaBetaFactorThisEvent_

std::auto_ptr< TFormula >	deltaBetaFormula_

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< reco::PFCandidateCollection >	pfCand_token

edm::InputTag	pfCandSrc_

std::auto_ptr< tau::RecoTauQualityCuts >	pileupQcutsGeneralQCuts_

std::auto_ptr< tau::RecoTauQualityCuts >	pileupQcutsPUTrackSelection_

std::auto_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::auto_ptr< tau::RecoTauVertexAssociator >	vertexAssociator_

edm::InputTag	vertexSrc_

double	weightGammas_

Additional Inherited Members
Public Types inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
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

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

double	prediscriminantFailValue_

edm::EDGetTokenT< TauCollection >	Tau_token

size_t	tauIndex_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 26 of file PFRecoTauDiscriminationByIsolation.cc.

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 29 of file PFRecoTauDiscriminationByIsolation.cc.

References Exception, edm::ParameterSet::exists(), reco::tau::factorizePUQCuts(), tauProducer_cfi::footprintCorrection, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), eostools::move(), PFRecoTauDiscriminationByIsolation_cfi::offset, 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.exists("ApplyDiscriminationByWeightedECALIsolation") ?
       pset.getParameter<bool>("ApplyDiscriminationByWeightedECALIsolation") : false;
 
     // RIC: multiply neutral isolation by a flat factor.
     //      Useful, for instance, to combine charged and neutral isolations
     //      with different relative weights
     weightGammas_ = pset.exists("WeightECALIsolation") ?
       pset.getParameter<double>("WeightECALIsolation") : 1.0;
 
     // RIC: allow to relax the isolation completely beyond a given tau pt
     minPtForNoIso_ = pset.exists("minTauPtForNoIso") ?
       pset.getParameter<double>("minTauPtForNoIso") : -99.;
     
     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.exists("relativeSumPtOffset") ?
       pset.getParameter<double>("relativeSumPtOffset") : 0.0;
 
     storeRawOccupancy_ = pset.exists("storeRawOccupancy") ?
       pset.getParameter<bool>("storeRawOccupancy") : false;
     storeRawSumPt_ = pset.exists("storeRawSumPt") ?
       pset.getParameter<bool>("storeRawSumPt") : false;
     storeRawPUsumPt_ = pset.exists("storeRawPUsumPt") ?
       pset.getParameter<bool>("storeRawPUsumPt") : false;
     storeRawFootprintCorrection_ = pset.exists("storeRawFootprintCorrection") ?
       pset.getParameter<bool>("storeRawFootprintCorrection") : false;
     storeRawPhotonSumPt_outsideSignalCone_ = pset.exists("storeRawPhotonSumPt_outsideSignalCone") ?
       pset.getParameter<bool>("storeRawPhotonSumPt_outsideSignalCone") : false;
 
     // 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.";
     }
 
     if ( pset.exists("customOuterCone") ) {
       customIsoCone_ = pset.getParameter<double>("customOuterCone");
     } else {
       customIsoCone_ = -1;
     }
 
     applyPhotonPtSumOutsideSignalConeCut_ = ( pset.exists("applyPhotonPtSumOutsideSignalConeCut") ) ?
       pset.getParameter<bool>("applyPhotonPtSumOutsideSignalConeCut") : false;
     if ( applyPhotonPtSumOutsideSignalConeCut_ ) {
       maxAbsPhotonSumPt_outsideSignalCone_ = pset.getParameter<double>("maxAbsPhotonSumPt_outsideSignalCone");
       maxRelPhotonSumPt_outsideSignalCone_ = pset.getParameter<double>("maxRelPhotonSumPt_outsideSignalCone");
     }
     
     applyFootprintCorrection_ = ( pset.exists("applyFootprintCorrection") ) ?
       pset.getParameter<bool>("applyFootprintCorrection") : false;
     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()));
 
     applyDeltaBeta_ = pset.exists("applyDeltaBetaCorrection") ?
       pset.getParameter<bool>("applyDeltaBetaCorrection") : false;
 
     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.
       if ( pset.exists("deltaBetaPUTrackPtCutOverride") ) {
     puFactorizedIsoQCuts.second.addParameter<double>(
       "minTrackPt",
       pset.getParameter<double>("deltaBetaPUTrackPtCutOverride"));
       } 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<reco::PFCandidateCollection>(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.exists("applyRhoCorrection") ?
       pset.getParameter<bool>("applyRhoCorrection") : false;
     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.exists("UseAllPFCandsForWeights") ?
       pset.getParameter<bool>("UseAllPFCandsForWeights") : false;
 
     verbosity_ = ( pset.exists("verbosity") ) ?
       pset.getParameter<int>("verbosity") : 0;
   }

PFRecoTauDiscriminationByIsolation::~PFRecoTauDiscriminationByIsolation ( )

inlineoverride

Definition at line 197 of file PFRecoTauDiscriminationByIsolation.cc.

198 {

199 }

Member Function Documentation

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

overridevirtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 295 of file PFRecoTauDiscriminationByIsolation.cc.

References reco::LeafCandidate::charge(), mps_fire::i, slimmedMuons_cfi::pfCandidates, and electrons_cff::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<reco::PFCandidateCollection> 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::PFCandidatePtr 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_;
   }
 }

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

override

Definition at line 335 of file PFRecoTauDiscriminationByIsolation.cc.

References gather_cfg::cout, DEFINE_FWK_MODULE, reco::deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, PVValHelper::eta, ALCARECOTkAlBeamHalo_cff::filter, tauProducer_cfi::footprintCorrection, edm::Ref< C, T, F >::isNonnull(), cmsBatch::log, LogDebug, LogTrace, min(), eostools::move(), reco::LeafCandidate::p4(), MetAnalyzer::pv(), and reco::LeafCandidate::setP4().

 {
     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<PFCandidatePtr> isoCharged_;
   std::vector<PFCandidatePtr> isoNeutral_;
   std::vector<PFCandidatePtr> isoPU_;
   PFCandidateCollection isoNeutralWeight_;
   std::vector<PFCandidatePtr> chPV_;
   isoCharged_.reserve(pfTau->isolationPFChargedHadrCands().size());
   isoNeutral_.reserve(pfTau->isolationPFGammaCands().size());
   isoPU_.reserve(std::min(100UL, chargedPFCandidatesInEvent_.size()));
   isoNeutralWeight_.reserve(pfTau->isolationPFGammaCands().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->leadPFChargedHadrCand().isNonnull() ) {
       LogTrace("discriminate") << "leadPFChargedHadron:" 
         << " Pt = " << pfTau->leadPFChargedHadrCand()->pt() << "," 
         << " eta = " << pfTau->leadPFChargedHadrCand()->eta() << "," 
         << " phi = " << pfTau->leadPFChargedHadrCand()->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->leadPFChargedHadrCand().isNonnull()) ) return 0.;
 
   qcuts_->setPV(pv);
   qcuts_->setLeadTrack(pfTau->leadPFChargedHadrCand());
 
   if ( applyDeltaBeta_ || calculateWeights_) {
     pileupQcutsGeneralQCuts_->setPV(pv);
     pileupQcutsGeneralQCuts_->setLeadTrack(pfTau->leadPFChargedHadrCand());
     pileupQcutsPUTrackSelection_->setPV(pv);
     pileupQcutsPUTrackSelection_->setLeadTrack(pfTau->leadPFChargedHadrCand());
   }
 
   // Load the tracks if they are being used.
   if ( includeTracks_ ) {
     for( auto const & cand : pfTau->isolationPFChargedHadrCands() ) {
       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->isolationPFGammaCands() ) {
       if ( qcuts_->filterCandRef(cand) ) {
     LogTrace("discriminate") << "adding neutral iso cand with pt " << cand->pt() ;
         isoNeutral_.push_back(cand);
       }
     }
   }
 
   typedef reco::tau::cone::DeltaRPtrFilter<PFCandidatePtr> DRFilter;
   typedef reco::tau::cone::DeltaRFilter<PFCandidate> 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<PFCandidatePtr> allPU =
       pileupQcutsPUTrackSelection_->filterCandRefs(
           chargedPFCandidatesInEvent_, true);
 
     std::vector<PFCandidatePtr> 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<PFCandidatePtr> cleanPU =
         pileupQcutsGeneralQCuts_->filterCandRefs(allPU);
 
       std::vector<PFCandidatePtr> 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));
       PFCandidate 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<PFCandidatePtr> isoCharged_filter;
     std::vector<PFCandidatePtr> isoNeutral_filter;
     PFCandidateCollection 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_ ) {
       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::PFCandidatePtr>& signalPFGammas = pfTau->signalPFGammaCands();
     for ( std::vector<reco::PFCandidatePtr>::const_iterator signalPFGamma = signalPFGammas.begin();
       signalPFGamma != signalPFGammas.end(); ++signalPFGamma ) {
       double dR = deltaR(pfTau->eta(), pfTau->phi(), (*signalPFGamma)->eta(), (*signalPFGamma)->phi());
       if ( dR > pfTau->signalConeSize() ) photonSumPt_outsideSignalCone += (*signalPFGamma)->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.);
   }
 }

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

inline

Definition at line 204 of file PFRecoTauDiscriminationByIsolation.cc.

References reco::deltaR2(), 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

bool PFRecoTauDiscriminationByIsolation::applyDeltaBeta_

private

Definition at line 269 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::applyFootprintCorrection_

private

Definition at line 244 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::applyOccupancyCut_

private

Definition at line 229 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::applyPhotonPtSumOutsideSignalConeCut_

private

Definition at line 240 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::applyRelativeSumPtCut_

private

Definition at line 233 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::applyRhoCorrection_

private

Definition at line 282 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::applySumPtCut_

private

Definition at line 231 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::calculateWeights_

private

Definition at line 227 of file PFRecoTauDiscriminationByIsolation.cc.

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

private

Definition at line 275 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::customIsoCone_

private

Definition at line 236 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::deltaBetaCollectionCone_

private

Definition at line 277 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::deltaBetaFactorThisEvent_

private

Definition at line 279 of file PFRecoTauDiscriminationByIsolation.cc.

std::auto_ptr<TFormula> PFRecoTauDiscriminationByIsolation::deltaBetaFormula_

private

Definition at line 278 of file PFRecoTauDiscriminationByIsolation.cc.

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

private

Definition at line 255 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::includeGammas_

private

Definition at line 226 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::includeTracks_

private

Definition at line 225 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::maxAbsPhotonSumPt_outsideSignalCone_

private

Definition at line 241 of file PFRecoTauDiscriminationByIsolation.cc.

uint32_t PFRecoTauDiscriminationByIsolation::maximumOccupancy_

private

Definition at line 230 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::maximumRelativeSumPt_

private

Definition at line 234 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::maximumSumPt_

private

Definition at line 232 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::maxRelPhotonSumPt_outsideSignalCone_

private

Definition at line 242 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::minPtForNoIso_

private

Definition at line 238 of file PFRecoTauDiscriminationByIsolation.cc.

std::string PFRecoTauDiscriminationByIsolation::moduleLabel_

private

Definition at line 214 of file PFRecoTauDiscriminationByIsolation.cc.

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

double PFRecoTauDiscriminationByIsolation::offsetRelativeSumPt_

private

Definition at line 235 of file PFRecoTauDiscriminationByIsolation.cc.

edm::EDGetTokenT<reco::PFCandidateCollection> PFRecoTauDiscriminationByIsolation::pfCand_token

private

Definition at line 271 of file PFRecoTauDiscriminationByIsolation.cc.

edm::InputTag PFRecoTauDiscriminationByIsolation::pfCandSrc_

private

Definition at line 270 of file PFRecoTauDiscriminationByIsolation.cc.

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

private

Definition at line 221 of file PFRecoTauDiscriminationByIsolation.cc.

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

private

Definition at line 220 of file PFRecoTauDiscriminationByIsolation.cc.

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

private

Definition at line 217 of file PFRecoTauDiscriminationByIsolation.cc.

edm::ParameterSet PFRecoTauDiscriminationByIsolation::qualityCutsPSet_

private

Definition at line 216 of file PFRecoTauDiscriminationByIsolation.cc.

edm::EDGetTokenT<double> PFRecoTauDiscriminationByIsolation::rho_token

private

Definition at line 285 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::rhoConeSize_

private

Definition at line 286 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::rhoCorrectionThisEvent_

private

Definition at line 288 of file PFRecoTauDiscriminationByIsolation.cc.

edm::InputTag PFRecoTauDiscriminationByIsolation::rhoProducer_

private

Definition at line 284 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::rhoThisEvent_

private

Definition at line 289 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::rhoUEOffsetCorrection_

private

Definition at line 287 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::storeRawFootprintCorrection_

private

Definition at line 261 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::storeRawOccupancy_

private

Definition at line 258 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::storeRawPhotonSumPt_outsideSignalCone_

private

Definition at line 262 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::storeRawPUsumPt_

private

Definition at line 260 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::storeRawSumPt_

private

Definition at line 259 of file PFRecoTauDiscriminationByIsolation.cc.

bool PFRecoTauDiscriminationByIsolation::useAllPFCands_

private

Definition at line 283 of file PFRecoTauDiscriminationByIsolation.cc.

int PFRecoTauDiscriminationByIsolation::verbosity_

private

Definition at line 292 of file PFRecoTauDiscriminationByIsolation.cc.

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

private

Definition at line 274 of file PFRecoTauDiscriminationByIsolation.cc.

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

private

Definition at line 223 of file PFRecoTauDiscriminationByIsolation.cc.

edm::InputTag PFRecoTauDiscriminationByIsolation::vertexSrc_

private

Definition at line 273 of file PFRecoTauDiscriminationByIsolation.cc.

double PFRecoTauDiscriminationByIsolation::weightGammas_

private

Definition at line 228 of file PFRecoTauDiscriminationByIsolation.cc.

Classes

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation