/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/DataFormats/PatCandidates/interface/Electron.h

Go to the documentation of this file.

//
// $Id: Electron.h,v 1.34 2011/06/08 20:40:18 rwolf 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/GsfTrackReco/interface/GsfTrack.h"
#include "DataFormats/PatCandidates/interface/Lepton.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::TrackRef track() const;
      using reco::RecoCandidate::track; // avoid hiding the base implementation
      void embedGsfElectronCore();
      void embedGsfTrack();
      void embedSuperCluster();
      void embedTrack();

      // ---- methods for electron ID ----
      float electronID(const std::string & name) const;
      bool isElectronIDAvailable(const std::string & name) const;
      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 ----
      reco::PFCandidateRef pfCandidateRef() const;
      void setPFCandidateRef(const reco::PFCandidateRef& ref) {
        pfCandidateRef_ = ref;
      }
      void embedPFCandidate();
      // get the number of non-null PF candidates
      size_t numberOfSourceCandidatePtrs() const {
        return pfCandidateRef_.isNonnull() ? 1 : 0;
      }
      reco::CandidatePtr sourceCandidatePtr( size_type i ) const;

      // ---- embed various impact parameters with errors ----
      //
      // example:
      //
      //    // this will return the muon inner track
      //    // transverse impact parameter
      //    // relative to the primary vertex
      //    muon->dB(pat::Muon::PV2D);
      //
      //    // this will return the uncertainty
      //    // on the muon inner track
      //    // transverse impact parameter
      //    // relative to the primary vertex
      //    // or -1.0 if there is no valid PV in the event
      //    muon->edB(pat::Muon::PV2D);
      //
      // IpType defines the type of the impact parameter
      // None is default and reverts to old behavior controlled by 
      // patMuons.usePV = True/False
      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);

    protected:
      void initImpactParameters(); // init IP defaults in a constructor

      // ---- for content embedding ----
      bool embeddedGsfElectronCore_;
      std::vector<reco::GsfElectronCore> gsfElectronCore_;
      bool embeddedGsfTrack_;
      std::vector<reco::GsfTrack> gsfTrack_;
      bool embeddedSuperCluster_;
      std::vector<reco::SuperCluster> superCluster_;
      bool embeddedTrack_;
      std::vector<reco::Track> track_;

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

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

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

      // V+Jets group selection variables.
      bool    cachedDB_;         // have these values been cached?
      double  dB_;               // dB and edB are the impact parameter at the primary vertex,
      double  edB_;              // dB and edB are the impact parameter at the primary vertex,

      // ---- cached impact parameters ----
      std::vector<bool>    cachedIP_;  // has the IP (former dB) been cached?
      std::vector<double>  ip_;        // dB and edB are the impact parameter at the primary vertex,
      std::vector<double>  eip_;       // and its uncertainty as recommended by the tracking group
      
  };
}

#endif