IsolationComputer.h

Go to the documentation of this file.

#ifndef PhysicsTools_Heppy_IsolationComputer_h
#define PhysicsTools_Heppy_IsolationComputer_h
 
#include <vector>
#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
 
namespace heppy {
  class IsolationComputer {
  public:
    IsolationComputer(float weightCone = -1) : weightCone_(weightCone) {}
 
    enum SelfVetoPolicy { selfVetoNone = 0, selfVetoAll = 1, selfVetoFirst = 2 };
    void setPackedCandidates(const std::vector<pat::PackedCandidate> &all,
                             int fromPV_thresh = 1,
                             float dz_thresh = 9999.,
                             float dxy_thresh = 9999.,
                             bool also_leptons = false);
 
    void addVetos(const reco::Candidate &cand);
 
    void clearVetos();
 
    float chargedAbsIso(const reco::Candidate &cand,
                        float dR,
                        float innerR = 0,
                        float threshold = 0,
                        SelfVetoPolicy selfVeto = selfVetoAll) const;
 
    float puAbsIso(const reco::Candidate &cand,
                   float dR,
                   float innerR = 0,
                   float threshold = 0,
                   SelfVetoPolicy selfVeto = selfVetoAll) const;
 
    float neutralAbsIsoRaw(const reco::Candidate &cand,
                           float dR,
                           float innerR = 0,
                           float threshold = 0,
                           SelfVetoPolicy selfVeto = selfVetoAll) const;
 
    float neutralHadAbsIsoRaw(const reco::Candidate &cand,
                              float dR,
                              float innerR = 0,
                              float threshold = 0,
                              SelfVetoPolicy selfVeto = selfVetoAll) const;
 
    float photonAbsIsoRaw(const reco::Candidate &cand,
                          float dR,
                          float innerR = 0,
                          float threshold = 0,
                          SelfVetoPolicy selfVeto = selfVetoAll) const;
 
    float neutralAbsIsoWeighted(const reco::Candidate &cand,
                                float dR,
                                float innerR = 0,
                                float threshold = 0,
                                SelfVetoPolicy selfVeto = selfVetoAll) const;
 
    float neutralHadAbsIsoWeighted(const reco::Candidate &cand,
                                   float dR,
                                   float innerR = 0,
                                   float threshold = 0,
                                   SelfVetoPolicy selfVeto = selfVetoAll) const;
 
    float photonAbsIsoWeighted(const reco::Candidate &cand,
                               float dR,
                               float innerR = 0,
                               float threshold = 0,
                               SelfVetoPolicy selfVeto = selfVetoAll) const;
 
  protected:
    const std::vector<pat::PackedCandidate> *allcands_;
    float weightCone_;
    // collections of objects, sorted in eta
    std::vector<const pat::PackedCandidate *> charged_, neutral_, pileup_;
    mutable std::vector<float> weights_;
    std::vector<const reco::Candidate *> vetos_;
 
    float isoSumRaw(const std::vector<const pat::PackedCandidate *> &cands,
                    const reco::Candidate &cand,
                    float dR,
                    float innerR,
                    float threshold,
                    SelfVetoPolicy selfVeto,
                    int pdgId = -1) const;
    float isoSumNeutralsWeighted(const reco::Candidate &cand,
                                 float dR,
                                 float innerR,
                                 float threshold,
                                 SelfVetoPolicy selfVeto,
                                 int pdgId = -1) const;
  };
 
}  // namespace heppy
 
#endif