PFPhotonIsolationCalculator.h

Go to the documentation of this file.

//--------------------------------------------------------------------------------------------------
// $Id $
//
// PFPhotonIsolationCalculator
//
// Class for calculating PFIsolation for Photons.
//This class takes
// PF Particle collection and the reconstructed vertex collection as input.
//
// Authors: Vasundhara Chetluru
// Modified specifically for Photons, to be used as configurable plug-in
// algorithm in the gedPhotonProducer, by N. Marinelli
//--------------------------------------------------------------------------------------------------

#ifndef PFPhotonIsolationCalculator_H
#define PFPhotonIsolationCalculator_H

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "DataFormats/Common/interface/Handle.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PileUpPFCandidate.h"
#include "DataFormats/ParticleFlowCandidate/interface/PileUpPFCandidateFwd.h"

#include "DataFormats/EgammaCandidates/interface/Photon.h"
#include "DataFormats/EgammaCandidates/interface/PhotonFwd.h"

#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"

class PFPhotonIsolationCalculator {
public:
  PFPhotonIsolationCalculator();
  ~PFPhotonIsolationCalculator();

  void setup(const edm::ParameterSet& conf);

public:
  void calculate(const reco::Photon*,
                 const edm::Handle<reco::PFCandidateCollection> pfCandidateHandle,
                 edm::Handle<reco::VertexCollection>& vertices,
                 const edm::Event& e,
                 const edm::EventSetup& es,
                 reco::Photon::PflowIsolationVariables& phoisol03);

private:
  enum VetoType {
    kElectron = -1,  // MVA for non-triggering electrons
    kPhoton = 1      // MVA for triggering electrons
  };

  void initializeRings(int iNumberOfRings, float fRingSize);

  float getIsolationPhoton() {
    fIsolationPhoton_ = fIsolationInRingsPhoton_[0];
    return fIsolationPhoton_;
  };
  float getIsolationNeutral() {
    fIsolationNeutral_ = fIsolationInRingsNeutral_[0];
    return fIsolationNeutral_;
  };
  float getIsolationCharged() {
    fIsolationCharged_ = fIsolationInRingsCharged_[0];
    return fIsolationCharged_;
  };
  float getIsolationChargedAll() { return fIsolationChargedAll_; };

  std::vector<float> getIsolationInRingsPhoton() { return fIsolationInRingsPhoton_; };
  std::vector<float> getIsolationInRingsNeutral() { return fIsolationInRingsNeutral_; };
  std::vector<float> getIsolationInRingsCharged() { return fIsolationInRingsCharged_; };
  std::vector<float> getIsolationInRingsChargedAll() { return fIsolationInRingsChargedAll_; };

  //Veto implementation
  float isPhotonParticleVetoed(const reco::PFCandidateRef pfIsoCand);
  float isPhotonParticleVetoed(const reco::PFCandidate* pfIsoCand);
  //
  float isNeutralParticleVetoed(const reco::PFCandidate* pfIsoCand);
  float isNeutralParticleVetoed(const reco::PFCandidateRef pfIsoCand);
  //
  float isChargedParticleVetoed(const reco::PFCandidate* pfIsoCand, edm::Handle<reco::VertexCollection> vertices);
  float isChargedParticleVetoed(const reco::PFCandidate* pfIsoCand,
                                reco::VertexRef vtx,
                                edm::Handle<reco::VertexCollection> vertices);
  float isChargedParticleVetoed(const reco::PFCandidateRef pfIsoCand,
                                reco::VertexRef vtx,
                                edm::Handle<reco::VertexCollection> vertices);

  reco::VertexRef chargedHadronVertex(edm::Handle<reco::VertexCollection> verticies, const reco::PFCandidate& pfcand);

  int matchPFObject(const reco::Photon* photon, const reco::PFCandidateCollection* pfParticlesColl);
  int matchPFObject(const reco::GsfElectron* photon, const reco::PFCandidateCollection* pfParticlesColl);

  float fGetIsolation(const reco::Photon* photon,
                      const edm::Handle<reco::PFCandidateCollection> pfCandidateHandle,
                      reco::VertexRef vtx,
                      edm::Handle<reco::VertexCollection> vertices);
  std::vector<float> fGetIsolationInRings(const reco::Photon* photon,
                                          edm::Handle<reco::PFCandidateCollection> pfCandidateHandle,
                                          reco::VertexRef vtx,
                                          edm::Handle<reco::VertexCollection> vertices);

  int iParticleType_;

  Bool_t fisInitialized_;
  float fIsolation_;
  float fIsolationPhoton_;
  float fIsolationNeutral_;
  float fIsolationCharged_;
  float fIsolationChargedAll_;

  std::vector<float> fIsolationInRings_;
  std::vector<float> fIsolationInRingsPhoton_;
  std::vector<float> fIsolationInRingsNeutral_;
  std::vector<float> fIsolationInRingsCharged_;
  std::vector<float> fIsolationInRingsChargedAll_;

  Bool_t bCheckClosestZVertex_;
  float fConeSize_;
  Bool_t bApplyVeto_;
  Bool_t bApplyDzDxyVeto_;
  Bool_t bApplyPFPUVeto_;
  Bool_t bApplyMissHitPhVeto_;
  Bool_t bUseCrystalSize_;

  Bool_t bDeltaRVetoBarrel_;
  Bool_t bDeltaRVetoEndcap_;

  Bool_t bRectangleVetoBarrel_;
  Bool_t bRectangleVetoEndcap_;

  float fDeltaRVetoBarrelPhotons_;
  float fDeltaRVetoBarrelNeutrals_;
  float fDeltaRVetoBarrelCharged_;

  float fDeltaRVetoEndcapPhotons_;
  float fDeltaRVetoEndcapNeutrals_;
  float fDeltaRVetoEndcapCharged_;

  float fNumberOfCrystalEndcapPhotons_;

  float fRectangleDeltaPhiVetoBarrelPhotons_;
  float fRectangleDeltaPhiVetoBarrelNeutrals_;
  float fRectangleDeltaPhiVetoBarrelCharged_;

  float fRectangleDeltaPhiVetoEndcapPhotons_;
  float fRectangleDeltaPhiVetoEndcapNeutrals_;
  float fRectangleDeltaPhiVetoEndcapCharged_;

  float fRectangleDeltaEtaVetoBarrelPhotons_;
  float fRectangleDeltaEtaVetoBarrelNeutrals_;
  float fRectangleDeltaEtaVetoBarrelCharged_;

  float fRectangleDeltaEtaVetoEndcapPhotons_;
  float fRectangleDeltaEtaVetoEndcapNeutrals_;
  float fRectangleDeltaEtaVetoEndcapCharged_;

  int iNumberOfRings_;
  int iMissHits_;

  float fRingSize_;
  //  float fDeltaR_;
  //  float fDeltaEta_;
  //float fDeltaPhi_;

  float fEta_;
  float fPhi_;
  float fEtaSC_;
  float fPhiSC_;

  float fPt_;
  float fVx_;
  float fVy_;
  float fVz_;

  reco::SuperClusterRef refSC;
  bool pivotInBarrel;
};

#endif