PFIsolationEstimator.h

Go to the documentation of this file.

//--------------------------------------------------------------------------------------------------
// $Id $
//
// PFIsolationEstimator
//
// Helper Class for calculating PFIsolation for Photons & Electron onthe fly. This class takes
//        PF Particle collection and the reconstructed vertex collection as input.
//
// Authors: Vasundhara Chetluru
//--------------------------------------------------------------------------------------------------


//#define STANDALONE   // <---- this line

#ifndef PFIsolationEstimator_H
#define PFIsolationEstimator_H

#ifndef STANDALONE
#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "RecoEcal/EgammaCoreTools/interface/EcalClusterLazyTools.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
#endif
#include <TROOT.h>
#include "TMVA/Factory.h"
#include "TMVA/Tools.h"
#include "TMVA/Reader.h"
#include "TH1.h"
#include "TH2.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/EgammaCandidates/interface/GsfElectron.h"

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

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

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

  void initializeElectronIsolation(Bool_t bApplyVeto);
  void initializePhotonIsolation(Bool_t bApplyVeto);
  void initializeElectronIsolationInRings(Bool_t bApplyVeto, int iNumberOfRings, float fRingSize);
  void initializePhotonIsolationInRings(Bool_t bApplyVeto, int iNumberOfRings, float fRingSize);
  void initializeRings(int iNumberOfRings, float fRingSize);
  Bool_t isInitialized() const { return fisInitialized; }

  float fGetIsolation(const reco::PFCandidate* pfCandidate,
                      const reco::PFCandidateCollection* pfParticlesColl,
                      reco::VertexRef vtx,
                      edm::Handle<reco::VertexCollection> vertices);
  std::vector<float> fGetIsolationInRings(const reco::PFCandidate* pfCandidate,
                                          const reco::PFCandidateCollection* pfParticlesColl,
                                          reco::VertexRef vtx,
                                          edm::Handle<reco::VertexCollection> vertices);

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

  float fGetIsolation(const reco::GsfElectron* electron,
                      const reco::PFCandidateCollection* pfParticlesColl,
                      const reco::VertexRef vtx,
                      edm::Handle<reco::VertexCollection> vertices);
  std::vector<float> fGetIsolationInRings(const reco::GsfElectron* electron,
                                          const reco::PFCandidateCollection* pfParticlesColl,
                                          reco::VertexRef vtx,
                                          edm::Handle<reco::VertexCollection> vertices);

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

  void setConeSize(float fValue = 0.4) { fConeSize = fValue; };

  void setParticleType(int iValue) { iParticleType = iValue; };

  //Veto booleans
  void setApplyVeto(Bool_t bValue = kTRUE) { bApplyVeto = bValue; };
  void setApplyPFPUVeto(Bool_t bValue = kFALSE) { bApplyPFPUVeto = bValue; };
  void setApplyDzDxyVeto(Bool_t bValue = kTRUE) { bApplyDzDxyVeto = bValue; };
  void setApplyMissHitPhVeto(Bool_t bValue = kFALSE) { bApplyMissHitPhVeto = bValue; };
  void setDeltaRVetoBarrel(Bool_t bValue = kTRUE) { bDeltaRVetoBarrel = bValue; };
  void setDeltaRVetoEndcap(Bool_t bValue = kTRUE) { bDeltaRVetoEndcap = bValue; };
  void setRectangleVetoBarrel(Bool_t bValue = kTRUE) { bRectangleVetoBarrel = bValue; };
  void setRectangleVetoEndcap(Bool_t bValue = kTRUE) { bRectangleVetoEndcap = bValue; };
  //Use crystal size
  void setUseCrystalSize(Bool_t bValue = kFALSE) { bUseCrystalSize = bValue; };

  //Veto Values
  void setDeltaRVetoBarrelPhotons(float fValue = -1.0) { fDeltaRVetoBarrelPhotons = fValue; };
  void setDeltaRVetoBarrelNeutrals(float fValue = -1.0) { fDeltaRVetoBarrelNeutrals = fValue; };
  void setDeltaRVetoBarrelCharged(float fValue = -1.0) { fDeltaRVetoBarrelCharged = fValue; };
  void setDeltaRVetoEndcapPhotons(float fValue = -1.0) { fDeltaRVetoEndcapPhotons = fValue; };
  void setDeltaRVetoEndcapNeutrals(float fValue = -1.0) { fDeltaRVetoEndcapNeutrals = fValue; };
  void setDeltaRVetoEndcapCharged(float fValue = -1.0) { fDeltaRVetoEndcapCharged = fValue; };
  void setNumberOfCrystalEndcapPhotons(float fValue = -1) { fNumberOfCrystalEndcapPhotons = fValue; };

  void setRectangleDeltaPhiVetoBarrelPhotons(float fValue = -1.0) { fRectangleDeltaPhiVetoBarrelPhotons = fValue; };
  void setRectangleDeltaPhiVetoBarrelNeutrals(float fValue = -1.0) { fRectangleDeltaPhiVetoBarrelNeutrals = fValue; };
  void setRectangleDeltaPhiVetoBarrelCharged(float fValue = -1.0) { fRectangleDeltaPhiVetoBarrelCharged = fValue; };
  void setRectangleDeltaPhiVetoEndcapPhotons(float fValue = -1.0) { fRectangleDeltaPhiVetoEndcapPhotons = fValue; };
  void setRectangleDeltaPhiVetoEndcapNeutrals(float fValue = -1.0) { fRectangleDeltaPhiVetoEndcapNeutrals = fValue; };
  void setRectangleDeltaPhiVetoEndcapCharged(float fValue = -1.0) { fRectangleDeltaPhiVetoEndcapCharged = fValue; };

  void setRectangleDeltaEtaVetoBarrelPhotons(float fValue = -1.0) { fRectangleDeltaEtaVetoBarrelPhotons = fValue; };
  void setRectangleDeltaEtaVetoBarrelNeutrals(float fValue = -1.0) { fRectangleDeltaEtaVetoBarrelNeutrals = fValue; };
  void setRectangleDeltaEtaVetoBarrelCharged(float fValue = -1.0) { fRectangleDeltaEtaVetoBarrelCharged = fValue; };
  void setRectangleDeltaEtaVetoEndcapPhotons(float fValue = -1.0) { fRectangleDeltaEtaVetoEndcapPhotons = fValue; };
  void setRectangleDeltaEtaVetoEndcapNeutrals(float fValue = -1.0) { fRectangleDeltaEtaVetoEndcapNeutrals = fValue; };
  void setRectangleDeltaEtaVetoEndcapCharged(float fValue = -1.0) { fRectangleDeltaEtaVetoEndcapCharged = fValue; };

  //Veto implementation
  float isPhotonParticleVetoed(const reco::PFCandidate* pfIsoCand);
  float isNeutralParticleVetoed(const reco::PFCandidate* 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 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; };

  void setNumbersOfRings(int iValue = 1) { iNumberOfRings = iValue; };
  void setRingSize(float fValue = 0.4) { fRingSize = fValue; };

  int getNumbersOfRings() { return iNumberOfRings; };
  float getRingSize() { return fRingSize; };

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

private:
  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 checkClosestZVertex;
  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;

  math::XYZVector vtxWRTCandidate;

  void initialize(Bool_t bApplyVeto, int iParticleType);
};

#endif