PFCandidateEGammaExtra.h

Go to the documentation of this file.

#ifndef ParticleFlowCandidate_PFCandidateEGammaExtra_h
#define ParticleFlowCandidate_PFCandidateEGammaExtra_h

#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlock.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementTrack.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockElementCluster.h"

#include <iosfwd>

namespace reco {
  typedef std::pair<reco::PFBlockRef, unsigned> ElementInBlock;
  typedef std::vector< ElementInBlock > ElementsInBlocks;

  class PFCandidateEGammaExtra { 
  public:    
    enum StatusFlag {
      X=0,                            // undefined
      Selected,                       // selected 
      ECALDrivenPreselected,          // ECAL-driven electron pre-selected
      MVASelected,                    // Passed the internal particle-flow selection (mva selection)
      Rejected                        // Rejected 
    };

    // if you had a variable update NMvaVariables 
    enum MvaVariable {
      MVA_FIRST=0,
      MVA_LnPtGsf=MVA_FIRST,
      MVA_EtaGsf,
      MVA_SigmaPtOverPt,
      MVA_Fbrem,
      MVA_Chi2Gsf,
      MVA_NhitsKf,
      MVA_Chi2Kf,
      MVA_EtotOverPin,
      MVA_EseedOverPout,
      MVA_EbremOverDeltaP,
      MVA_DeltaEtaTrackCluster,
      MVA_LogSigmaEtaEta,
      MVA_HOverHE,
      MVA_LateBrem,
      MVA_FirstBrem,
      MVA_MVA,
      MVA_LAST
    };

    enum ElectronVetoes {
      kFailsMVA,
      kKFTracksOnGSFCluster, // any number of additional tracks on GSF cluster
      kFailsTrackAndHCALIso, // > 3 kfs on Gsf-cluster, bad h/e
      kKillAdditionalKFs,    // tracks with hcal linkbut good gsf etot/p_in 
      kItIsAPion,            // bad H/P_in, H/H+E, and E_tot/P_in
      kCrazyEoverP,          // screwey track linking / weird GSFs
      kTooLargeAngle,        // angle between GSF and RSC centroid too large
      kN_EVETOS
    };

    enum PhotonVetoes {
      kFailsTrackIso, // the photon fails tracker isolation
      kN_PHOVETOS
    };

  public:
    PFCandidateEGammaExtra();
    PFCandidateEGammaExtra(const GsfTrackRef&);
    ~PFCandidateEGammaExtra(){;}

    void setGsfTrackRef(const reco::GsfTrackRef& ref);   

    void setKfTrackRef(const reco::TrackRef & ref);

    void setGsfElectronClusterRef(const reco::PFBlockRef& blk,
                  const reco::PFBlockElementCluster& ref) {
      eleGsfCluster_ = ElementInBlock(blk,ref.index());
    }

    reco::GsfTrackRef gsfTrackRef() const { return gsfTrackRef_; }     

    reco::TrackRef kfTrackRef() const { return kfTrackRef_; }

    const ElementInBlock& gsfElectronClusterRef() const { 
      return eleGsfCluster_; 
    }

    reco::SuperClusterRef superClusterRef() const {return scRef_ ; }

    reco::SuperClusterRef superClusterPFECALRef() const {return scPFECALRef_ ; }    
    
    void setSuperClusterRef(reco::SuperClusterRef sc) { scRef_ = sc; }

    void setSuperClusterPFECALRef(reco::SuperClusterRef sc) { scPFECALRef_ = sc; }   
    
    void addSingleLegConvTrackRef(const reco::TrackRef& trackref);

    const std::vector<reco::TrackRef>& singleLegConvTrackRef() const {return assoSingleLegRefTrack_;}

    void addSingleLegConvMva(const float& mvasingleleg);

    const std::vector<float>& singleLegConvMva() const {return assoSingleLegMva_;}

    void addConversionRef(const reco::ConversionRef& convref);

    reco::ConversionRefVector conversionRef() const {return assoConversionsRef_;}     
    
    void setLateBrem(float val); 
    void setEarlyBrem(float val);

    void setGsfTrackPout(const math::XYZTLorentzVector& pout);
    
    void setClusterEnergies(const std::vector<float>& energies);

    void setSigmaEtaEta(float val);

    void setDeltaEta(float val);

    void setHadEnergy(float val);

    void setMVA(float val);

    void setStatus(StatusFlag type,bool status=true);

    bool electronStatus(StatusFlag) const ;

    int electronStatus() const {return status_;}

    bool mvaStatus(MvaVariable flag) const;

    const std::vector<float> & mvaVariables() const {return mvaVariables_;}

    float mvaVariable(MvaVariable var) const;

    float hadEnergy() const {return hadEnergy_;}
    float sigmaEtaEta() const {return sigmaEtaEta_;}

    void addExtraNonConvTrack(const reco::PFBlockRef& blk,
                  const reco::PFBlockElementTrack& tkref) {
      if( !tkref.trackType(reco::PFBlockElement::T_FROM_GAMMACONV) ) {
    assoNonConvExtraTracks_.push_back(std::make_pair(blk,tkref.index()));
      }
    }
    const ElementsInBlocks& extraNonConvTracks() const {
      return assoNonConvExtraTracks_;
    }        

 private:
    void  setVariable(MvaVariable type,float var);
    
 private:
    reco::GsfTrackRef gsfTrackRef_;
    reco::TrackRef kfTrackRef_;
    ElementInBlock eleGsfCluster_;

    reco::SuperClusterRef scRef_;

    reco::SuperClusterRef scPFECALRef_;    
    
    std::vector<reco::TrackRef> assoSingleLegRefTrack_;
    
    // information for track matching
    ElementsInBlocks assoNonConvExtraTracks_;    

    std::vector<float> assoSingleLegMva_;

    reco::ConversionRefVector assoConversionsRef_;    
    
    std::vector<float> clusterEnergies_;

    std::vector<float> mvaVariables_;
    
    int mvaStatus_;

    int status_;

    math::XYZTLorentzVector pout_;
    float earlyBrem_;
    float lateBrem_;
    float sigmaEtaEta_;
    float hadEnergy_;
    float deltaEta_;
  };

  std::ostream& operator<<( std::ostream& out, const PFCandidateEGammaExtra& c );

}
#endif