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