Electron.h

Go to the documentation of this file.

//
// $Id: Electron.h,v 1.46 2013/04/11 22:42:32 beaudett Exp $
//

#ifndef DataFormats_PatCandidates_Electron_h
#define DataFormats_PatCandidates_Electron_h

#include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectronCore.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectronCoreFwd.h"
#include "DataFormats/EgammaReco/interface/BasicCluster.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
#include "DataFormats/PatCandidates/interface/Lepton.h"

#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"

// Define typedefs for convenience
namespace pat {
  class Electron;
  typedef std::vector<Electron>              ElectronCollection;
  typedef edm::Ref<ElectronCollection>       ElectronRef;
  typedef edm::RefVector<ElectronCollection> ElectronRefVector;
}

namespace reco {
  std::ostream& operator<<(std::ostream& out, const pat::Electron& obj);
}

// Class definition
namespace pat {


  class Electron : public Lepton<reco::GsfElectron> {

    public:

      typedef std::pair<std::string,float> IdPair;

      Electron();
      Electron(const reco::GsfElectron & anElectron);
      Electron(const edm::RefToBase<reco::GsfElectron> & anElectronRef);
      Electron(const edm::Ptr<reco::GsfElectron> & anElectronRef);
      virtual ~Electron();

      virtual Electron * clone() const { return new Electron(*this); }

      // ---- methods for content embedding ----
      virtual reco::GsfElectronCoreRef core() const;
      reco::GsfTrackRef gsfTrack() const;
      reco::SuperClusterRef superCluster() const;
      reco::SuperClusterRef pflowSuperCluster() const;
      reco::TrackRef track() const;
      reco::TrackRef closestCtfTrackRef() const;
      reco::CaloClusterPtr seed() const; 

      //method to access the basic clusters
      const std::vector<reco::CaloCluster>& basicClusters() const { return basicClusters_ ; }
      //method to access the preshower clusters
      const std::vector<reco::CaloCluster>& preshowerClusters() const { return preshowerClusters_ ; }
      //method to access the pflow basic clusters
      const std::vector<reco::CaloCluster>& pflowBasicClusters() const { return pflowBasicClusters_ ; }
      //method to access the pflow preshower clusters
      const std::vector<reco::CaloCluster>& pflowPreshowerClusters() const { return pflowPreshowerClusters_ ; }

      using reco::RecoCandidate::track; // avoid hiding the base implementation
      void embedGsfElectronCore();
      void embedGsfTrack();
      void embedSuperCluster();
      void embedPflowSuperCluster();
      void embedSeedCluster();
      void embedBasicClusters();
      void embedPreshowerClusters();
      void embedPflowBasicClusters();
      void embedPflowPreshowerClusters();
      void embedTrack();
      void embedRecHits(const EcalRecHitCollection * rechits); 

      // ---- methods for electron ID ----
      // For cut-based IDs, the value map has the following meaning:
      // 0: fails,
      // 1: passes electron ID only,
      // 2: passes electron Isolation only,
      // 3: passes electron ID and Isolation only,
      // 4: passes conversion rejection,
      // 5: passes conversion rejection and ID,
      // 6: passes conversion rejection and Isolation,
      // 7: passes the whole selection.
      // For more details have a look at:
      // https://twiki.cern.ch/twiki/bin/view/CMS/SimpleCutBasedEleID
      // https://twiki.cern.ch/twiki/bin/view/CMS/SWGuideCategoryBasedElectronID
      // Note: an exception is thrown if the specified ID is not available
      float electronID(const std::string& name) const;
      float electronID(const char* name) const { return electronID( std::string(name) );}
      bool isElectronIDAvailable(const std::string& name) const;
      bool isElectronIDAvailable(const char* name) const {
    return isElectronIDAvailable(std::string(name));
      }
      const std::vector<IdPair> &  electronIDs() const { return electronIDs_; }
      void setElectronIDs(const std::vector<IdPair> & ids) { electronIDs_ = ids; }

      // ---- overload of isolation functions ----
      float trackIso() const { return dr04TkSumPt(); }
      float ecalIso()  const { return dr04EcalRecHitSumEt(); }
      float hcalIso()  const { return dr04HcalTowerSumEt(); }
      float caloIso()  const { return ecalIso()+hcalIso(); }

      // ---- PF specific methods ----
      bool isPF() const{ return isPF_; }
      void setIsPF(bool hasPFCandidate) { isPF_ = hasPFCandidate ; }

      reco::PFCandidateRef pfCandidateRef() const;
      void setPFCandidateRef(const reco::PFCandidateRef& ref) {
        pfCandidateRef_ = ref;
      }
      void embedPFCandidate();
      size_t numberOfSourceCandidatePtrs() const {
        return pfCandidateRef_.isNonnull() ? 1 : 0;
      }
      reco::CandidatePtr sourceCandidatePtr( size_type i ) const;

      // ---- embed various impact parameters with errors ----
      typedef enum IPTYPE { None = 0, PV2D = 1, PV3D = 2, BS2D = 3, BS3D = 4 } IpType;
      double dB(IpType type = None) const;
      double edB(IpType type = None) const;
      void setDB(double dB, double edB, IpType type = None);

      // ---- Momentum estimate specific methods ----
      const LorentzVector & ecalDrivenMomentum() const {return ecalDrivenMomentum_;}
      void setEcalDrivenMomentum(const Candidate::LorentzVector& mom) {ecalDrivenMomentum_=mom;}

      friend std::ostream& reco::operator<<(std::ostream& out, const pat::Electron& obj);

      double r9() const { return r9_; };
      double sigmaIphiIphi() const { return sigmaIphiIphi_; };
      double sigmaIetaIphi() const { return sigmaIetaIphi_; };
      double ip3d() const { return ip3d_; }
      void setMvaVariables( double r9, double sigmaIphiIphi, double sigmaIetaIphi, double ip3d );

      const EcalRecHitCollection * recHits() const { return &recHits_;}

      double ecalRegressionEnergy() const { return ecalRegressionEnergy_;}
      double ecalRegressionError() const { return ecalRegressionError_;}
      double ecalTrackRegressionEnergy() const { return ecalTrackRegressionEnergy_; }
      double ecalTrackRegressionError() const { return ecalTrackRegressionError_; }
      void setEcalRegressionEnergy(double val, double err) { ecalRegressionEnergy_ = val; ecalRegressionError_ = err; }
      void setEcalTrackRegressionEnergy(double val, double err) { ecalTrackRegressionEnergy_ = val; ecalTrackRegressionError_ = err; }

      void setEcalScale(double val) { ecalScale_= val ;}               
      void setEcalSmear(double val) { ecalSmear_= val;}                
      void setEcalRegressionScale(double val) { ecalRegressionScale_ = val ;}     
      void setEcalRegressionSmear(double val) { ecalRegressionSmear_ = val;}     
      void setEcalTrackRegressionScale(double val) { ecalTrackRegressionScale_ = val;}
      void setEcalTrackRegressionSmear(double val) { ecalTrackRegressionSmear_ = val;}

      double ecalScale() const  { return ecalScale_ ;}               
      double ecalSmear() const  { return ecalSmear_;}                
      double ecalRegressionScale() const  { return ecalRegressionScale_  ;}     
      double ecalRegressionSmear() const  { return ecalRegressionSmear_ ;}     
      double ecalTrackRegressionScale() const  { return ecalTrackRegressionScale_ ;}
      double ecalTrackRegressionSmear() const  { return ecalTrackRegressionSmear_ ;}
      bool passConversionVeto() const { return passConversionVeto_; }
      void setPassConversionVeto( bool flag ) { passConversionVeto_ = flag; }

    protected:
      void initImpactParameters();

      // ---- for content embedding ----
      bool embeddedGsfElectronCore_;
      std::vector<reco::GsfElectronCore> gsfElectronCore_;
      bool embeddedGsfTrack_;
      std::vector<reco::GsfTrack> gsfTrack_;
      bool embeddedSuperCluster_;
      bool embeddedPflowSuperCluster_;
      std::vector<reco::SuperCluster> superCluster_;
      std::vector<reco::CaloCluster> basicClusters_;
      std::vector<reco::CaloCluster> preshowerClusters_;
      std::vector<reco::CaloCluster> pflowBasicClusters_;
      std::vector<reco::CaloCluster> pflowPreshowerClusters_;
      std::vector<reco::SuperCluster> pflowSuperCluster_;
      bool embeddedTrack_;
      std::vector<reco::Track> track_;
      bool embeddedSeedCluster_;
      std::vector<reco::CaloCluster> seedCluster_;
      bool embeddedRecHits_;    
      EcalRecHitCollection recHits_;

      // ---- electron ID's holder ----
      std::vector<IdPair> electronIDs_;

      // ---- PF specific members ----
      bool isPF_;
      bool embeddedPFCandidate_;
      reco::PFCandidateCollection pfCandidate_;
      reco::PFCandidateRef pfCandidateRef_;

      // ---- specific members : Momentum estimates ----
      LorentzVector ecalDrivenMomentum_;

      // V+Jets group selection variables.
      bool    cachedDB_;
      double  dB_;
      double  edB_;

      double r9_;
      double sigmaIphiIphi_;
      double sigmaIetaIphi_;
      double ip3d_;

      double ecalRegressionEnergy_;
      double ecalTrackRegressionEnergy_;
      double ecalRegressionError_;
      double ecalTrackRegressionError_;

      double ecalScale_;
      double ecalSmear_;

      double ecalRegressionScale_;
      double ecalRegressionSmear_;

      double ecalTrackRegressionScale_;
      double ecalTrackRegressionSmear_;
      
      
      bool passConversionVeto_;

      // ---- cached impact parameters ----
      std::vector<bool>    cachedIP_;
      std::vector<double>  ip_;
      std::vector<double>  eip_;
  };
}

#endif