Inheritance diagram for PFRecoTauDiscriminationByIsolation:

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

double	discriminate (const PFTauRef &pfTau)

	PFRecoTauDiscriminationByIsolation (const edm::ParameterSet &pset)

	~PFRecoTauDiscriminationByIsolation ()

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

virtual void	endEvent (edm::Event &evt)

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

	TauDiscriminationProducerBase (const edm::ParameterSet &iConfig)

	TauDiscriminationProducerBase ()

virtual	~TauDiscriminationProducerBase ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

boost::function< void(const BranchDescription &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Private Attributes
bool	applyDeltaBeta_

bool	applyOccupancyCut_

bool	applyRelativeSumPtCut_

bool	applyRhoCorrection_

bool	applySumPtCut_

std::vector< reco::PFCandidateRef >	chargedPFCandidatesInEvent_

double	customIsoCone_

double	deltaBetaCollectionCone_

double	deltaBetaFactorThisEvent_

std::auto_ptr< TFormula >	deltaBetaFormula_

bool	includeGammas_

bool	includeTracks_

uint32_t	maximumOccupancy_

double	maximumRelativeSumPt_

double	maximumSumPt_

edm::InputTag	pfCandSrc_

std::auto_ptr < tau::RecoTauQualityCuts >	pileupQcutsGeneralQCuts_

std::auto_ptr < tau::RecoTauQualityCuts >	pileupQcutsPUTrackSelection_

std::auto_ptr < tau::RecoTauQualityCuts >	qcuts_

edm::ParameterSet	qualityCutsPSet_

double	rhoConeSize_

double	rhoCorrectionThisEvent_

edm::InputTag	rhoProducer_

double	rhoThisEvent_

double	rhoUEOffsetCorrection_

bool	storeRawOccupancy_

bool	storeRawSumPt_

std::auto_ptr < tau::RecoTauVertexAssociator >	vertexAssociator_

edm::InputTag	vertexSrc_

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::EDProducer
typedef EDProducer	ModuleType

typedef WorkerT< EDProducer >	WorkerType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Protected Attributes inherited from TauDiscriminationProducerBase< TauType, TauDiscriminator >
double	prediscriminantFailValue_

edm::InputTag	TauProducer_

Detailed Description

Definition at line 25 of file PFRecoTauDiscriminationByIsolation.cc.

Constructor & Destructor Documentation

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

inlineexplicit

Definition at line 28 of file PFRecoTauDiscriminationByIsolation.cc.

References edm::hlt::Exception, edm::ParameterSet::exists(), reco::tau::factorizePUQCuts(), edm::ParameterSet::getParameter(), and edm::ParameterSet::getParameterSet().

                                                                             :
       PFTauDiscriminationProducerBase(pset),
       qualityCutsPSet_(pset.getParameter<edm::ParameterSet>("qualityCuts")) {
 
         includeTracks_ = pset.getParameter<bool>(
             "ApplyDiscriminationByTrackerIsolation");
         includeGammas_ = pset.getParameter<bool>(
             "ApplyDiscriminationByECALIsolation");
 
         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");
 
         storeRawOccupancy_ = pset.exists("storeRawOccupancy") ?
           pset.getParameter<bool>("storeRawOccupancy") : false;
         storeRawSumPt_ = pset.exists("storeRawSumPt") ?
           pset.getParameter<bool>("storeRawSumPt") : 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_) {
             throw cms::Exception("BadIsoConfig") <<
               "A 'store raw' and a 'apply cut' option have been set to true "
               << "simultaneously.  These options are mutually exclusive.";
           }
         }
 
         // Can only store one type
         if (storeRawSumPt_ && storeRawOccupancy_) {
             throw cms::Exception("BadIsoConfig") <<
               "Both 'store sum pt' and 'store occupancy' options are set."
               << " These options are mutually exclusive.";
         }
 
         if (pset.exists("customOuterCone")) {
           customIsoCone_ = pset.getParameter<double>("customOuterCone");
         } else {
           customIsoCone_ = -1;
         }
 
         // 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_));
 
         applyDeltaBeta_ = pset.exists("applyDeltaBetaCorrection") ?
           pset.getParameter<bool>("applyDeltaBetaCorrection") : false;
 
         if (applyDeltaBeta_) {
           // 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");
           vertexSrc_ = pset.getParameter<edm::InputTag>("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");
           rhoConeSize_ = pset.getParameter<double>("rhoConeSize");
           rhoUEOffsetCorrection_ =
             pset.getParameter<double>("rhoUEOffsetCorrection");
         }
       }

PFRecoTauDiscriminationByIsolation::~PFRecoTauDiscriminationByIsolation ( )

inline

Definition at line 133 of file PFRecoTauDiscriminationByIsolation.cc.

133 {}

Member Function Documentation

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

virtual

Reimplemented from TauDiscriminationProducerBase< TauType, TauDiscriminator >.

Definition at line 187 of file PFRecoTauDiscriminationByIsolation.cc.

References i.

                                      {
 
   // 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.
   chargedPFCandidatesInEvent_.clear();
   if (applyDeltaBeta_) {
     // Collect all the PF pile up tracks
     edm::Handle<reco::PFCandidateCollection> pfCandHandle_;
     event.getByLabel(pfCandSrc_, pfCandHandle_);
     chargedPFCandidatesInEvent_.reserve(pfCandHandle_->size());
     for (size_t i = 0; i < pfCandHandle_->size(); ++i) {
       reco::PFCandidateRef pfCand(pfCandHandle_, i);
       if (pfCand->charge() != 0)
         chargedPFCandidatesInEvent_.push_back(pfCand);
     }
     // Count all the vertices in the event, to parameterize the DB
     // correction factor
     edm::Handle<reco::VertexCollection> vertices;
     event.getByLabel(vertexSrc_, vertices);
     size_t nVtxThisEvent = vertices->size();
     deltaBetaFactorThisEvent_ = deltaBetaFormula_->Eval(nVtxThisEvent);
   }
 
   if (applyRhoCorrection_) {
     edm::Handle<double> rhoHandle_;
     event.getByLabel(rhoProducer_, rhoHandle_);
     rhoThisEvent_ = (*rhoHandle_ - rhoUEOffsetCorrection_)*
       (3.14159)*rhoConeSize_*rhoConeSize_;
   }
 }

double PFRecoTauDiscriminationByIsolation::discriminate ( const PFTauRef & pfTau )

Definition at line 226 of file PFRecoTauDiscriminationByIsolation.cc.

References alcazmumu_cfi::filter.

                                                                       {
   // collect the objects we are working with (ie tracks, tracks+gammas, etc)
   std::vector<PFCandidateRef> isoCharged;
   std::vector<PFCandidateRef> isoNeutral;
   std::vector<PFCandidateRef> isoPU;
 
   // 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.
   qcuts_->setPV(pv);
   qcuts_->setLeadTrack(pfTau->leadPFChargedHadrCand());
   if (applyDeltaBeta_) {
     pileupQcutsGeneralQCuts_->setPV(pv);
     pileupQcutsGeneralQCuts_->setLeadTrack(pfTau->leadPFChargedHadrCand());
     pileupQcutsPUTrackSelection_->setPV(pv);
     pileupQcutsPUTrackSelection_->setLeadTrack(pfTau->leadPFChargedHadrCand());
   }
   // Load the tracks if they are being used.
   if (includeTracks_) {
     BOOST_FOREACH(const reco::PFCandidateRef& cand,
         pfTau->isolationPFChargedHadrCands()) {
       if (qcuts_->filterRef(cand))
         isoCharged.push_back(cand);
     }
   }
 
   if (includeGammas_) {
     BOOST_FOREACH(const reco::PFCandidateRef& cand,
         pfTau->isolationPFGammaCands()) {
       if (qcuts_->filterRef(cand))
         isoNeutral.push_back(cand);
     }
   }
   typedef reco::tau::cone::DeltaRPtrFilter<PFCandidateRef> DRFilter;
 
   // If desired, get PU tracks.
   if (applyDeltaBeta_) {
     // First select by inverted the DZ/track weight cuts. True = invert
     //std::cout << "Initial PFCands: " << chargedPFCandidatesInEvent_.size()
     //  << std::endl;
 
     std::vector<PFCandidateRef> allPU =
       pileupQcutsPUTrackSelection_->filterRefs(
           chargedPFCandidatesInEvent_, true);
 
     //std::cout << "After track cuts: " << allPU.size() << std::endl;
 
     // Now apply the rest of the cuts, like pt, and TIP, tracker hits, etc
     std::vector<PFCandidateRef> cleanPU =
       pileupQcutsGeneralQCuts_->filterRefs(allPU);
 
     //std::cout << "After cleaning cuts: " << cleanPU.size() << std::endl;
 
     // Only select PU tracks inside the isolation cone.
     DRFilter deltaBetaFilter(pfTau->p4(), 0, deltaBetaCollectionCone_);
     BOOST_FOREACH(const reco::PFCandidateRef& cand, cleanPU) {
       if (deltaBetaFilter(cand)) {
         isoPU.push_back(cand);
       }
     }
     //std::cout << "After cone cuts: " << isoPU.size() << std::endl;
   }
 
   // Check if we want a custom iso cone
   if (customIsoCone_ >= 0.) {
     DRFilter filter(pfTau->p4(), 0, customIsoCone_);
     std::vector<PFCandidateRef> isoCharged_filter;
     std::vector<PFCandidateRef> isoNeutral_filter;
     // Remove all the objects not in our iso cone
      BOOST_FOREACH(const PFCandidateRef& isoObject, isoCharged) {
       if(filter(isoObject)) isoCharged_filter.push_back(isoObject);
     }
     BOOST_FOREACH(const PFCandidateRef& isoObject, isoNeutral) {
       if(filter(isoObject)) isoNeutral_filter.push_back(isoObject);
     }
     isoCharged.clear();
     isoCharged=isoCharged_filter;
     isoNeutral.clear();
     isoNeutral=isoNeutral_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 totalPt=0.0;
   //--- Sum PT requirement
   if( applySumPtCut_ || applyRelativeSumPtCut_ || storeRawSumPt_) {
     double chargedPt=0.0;
     double puPt=0.0;
     double neutralPt=0.0;
     BOOST_FOREACH(const PFCandidateRef& isoObject, isoCharged) {
       chargedPt += isoObject->pt();
     }
     BOOST_FOREACH(const PFCandidateRef& isoObject, isoNeutral) {
       neutralPt += isoObject->pt();
     }
     BOOST_FOREACH(const PFCandidateRef& isoObject, isoPU) {
       puPt += isoObject->pt();
     }
 
     if (applyDeltaBeta_) {
       neutralPt -= deltaBetaFactorThisEvent_*puPt;
     }
 
     if (applyRhoCorrection_) {
       neutralPt -= rhoThisEvent_;
     }
 
     if (neutralPt < 0.0) {
       neutralPt = 0.0;
     }
 
     totalPt = chargedPt+neutralPt;
 
     failsSumPtCut = (totalPt > maximumSumPt_);
 
     //--- Relative Sum PT requirement
     failsRelativeSumPtCut = (
         (pfTau->pt() > 0 ? totalPt/pfTau->pt() : 0 ) > maximumRelativeSumPt_ );
   }
 
   bool fails = (applyOccupancyCut_ && failsOccupancyCut) ||
     (applySumPtCut_ && failsSumPtCut) ||
     (applyRelativeSumPtCut_ && failsRelativeSumPtCut);
 
   // We did error checking in the constructor, so this is safe.
   if (storeRawSumPt_)
     return totalPt;
   else if (storeRawOccupancy_)
     return nOccupants;
   else
     return (fails ? 0. : 1.);
 }