Electron.h

Go to the documentation of this file.

//
//

#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"
#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
#include "DataFormats/Common/interface/AtomicPtrCache.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 PATElectronSlimmer;

  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 parentSuperCluster() 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(); }
      float ecalPFClusterIso() const { return ecalPFClusIso_; };
      float hcalPFClusterIso() const { return hcalPFClusIso_; };
      void setEcalPFClusterIso(float ecalPFClus) { ecalPFClusIso_ = ecalPFClus; };
      void setHcalPFClusterIso(float hcalPFClus) { hcalPFClusIso_ = hcalPFClus; };

      // ---- 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) + associatedPackedFCandidateIndices_.size();
      }
      reco::CandidatePtr sourceCandidatePtr( size_type i ) const;

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

      // ---- 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);

      float sigmaIetaIphi() const { return sigmaIetaIphi_; }
      float full5x5_sigmaIetaIphi() const { return full5x5_sigmaIetaIphi_; }
      double ip3d() const { return ip3d_; }
      void setMvaVariables( double sigmaIetaIphi, double ip3d );
      void full5x5_setSigmaIetaIphi(float sigmaIetaIphi) { full5x5_sigmaIetaIphi_ = sigmaIetaIphi; }

      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; }

      edm::RefVector<pat::PackedCandidateCollection> associatedPackedPFCandidates() const ;
      template<typename T>
      void setAssociatedPackedPFCandidates(const edm::RefProd<pat::PackedCandidateCollection> & refprod,
                                           T beginIndexItr,
                                           T endIndexItr) {
        packedPFCandidates_ = refprod;
        associatedPackedFCandidateIndices_.clear();
        associatedPackedFCandidateIndices_.insert(associatedPackedFCandidateIndices_.end(),
                                                  beginIndexItr,
                                                  endIndexItr);
      }

      friend class PATElectronSlimmer;

    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_;
      edm::AtomicPtrCache<std::vector<reco::SuperCluster> > superClusterRelinked_;
      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_;

      float sigmaIetaIphi_, full5x5_sigmaIetaIphi_;
      double ip3d_;

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

      double ecalScale_;
      double ecalSmear_;

      double ecalRegressionScale_;
      double ecalRegressionSmear_;

      double ecalTrackRegressionScale_;
      double ecalTrackRegressionSmear_;
      
      float ecalPFClusIso_;
      float hcalPFClusIso_;

      bool passConversionVeto_;

      // ---- cached impact parameters ----
      uint8_t    cachedIP_;
      float  ip_[IpTypeSize];    
      float  eip_[IpTypeSize];      

      // ---- link to PackedPFCandidates
      edm::RefProd<pat::PackedCandidateCollection> packedPFCandidates_;
      std::vector<uint16_t> associatedPackedFCandidateIndices_;
  };
}

#endif