LeafCandidate.h

Go to the documentation of this file.

#ifndef Candidate_LeafCandidate_h
#define Candidate_LeafCandidate_h

#include "DataFormats/Candidate/interface/Candidate.h"

#include "DataFormats/Candidate/interface/iterator_imp_specific.h"

#include "DataFormats/Math/interface/PtEtaPhiMass.h"
#include "DataFormats/GeometryVector/interface/GlobalVector.h"


namespace reco {
  
  class LeafCandidate : public Candidate {
  public:
    typedef CandidateCollection daughters;
    typedef int Charge;
    typedef math::XYZTLorentzVector LorentzVector;
    typedef math::PtEtaPhiMLorentzVector PolarLorentzVector;
    typedef math::XYZPoint Point;
    typedef math::XYZVector Vector;

    typedef unsigned int index;

    static double magd(GlobalVector v) { return std::sqrt(double(v.x())*double(v.x()) + double(v.y())*double(v.y()) + double(v.z())*double(v.z()) );}
    static double dmass(GlobalVector v, double e) { double m2 = e*e-magd(v); return m2>0 ? std::sqrt(m2) : 0;}

    LeafCandidate() : 
      qx3_(0), pt_(0), eta_(0), phi_(0), mass_(0), 
      vertex_(0, 0, 0), pdgId_(0), status_(0),
      cachePolarFixed_( false ), cacheCartesianFixed_( false ) { }
    // constructor from candidate                                                         
    explicit LeafCandidate( const Candidate & c) :
    qx3_( c.charge()*3 ), pt_( c.p4().pt() ), eta_( c.p4().eta() ), phi_( c.p4().phi() )
    , mass_( c.p4().mass() ),
    vertex_( c.vertex() ), pdgId_( c.pdgId() ), status_( c.status() ),
    cachePolarFixed_( false ), cacheCartesianFixed_( false ) {}
    
    template<typename P4>
    LeafCandidate( Charge q, const P4 & p4, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true ) :
      qx3_(integerCharge ? 3*q : q ), pt_( p4.pt() ), eta_( p4.eta() ), phi_( p4.phi() ), mass_( p4.mass() ),
      vertex_( vtx ), pdgId_( pdgId ), status_( status ),
      cachePolarFixed_( false ), cacheCartesianFixed_( false ) {}


    LeafCandidate( Charge q, const PtEtaPhiMass & p4, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true ) :
      qx3_(integerCharge ? 3*q : q ), pt_( p4.pt() ), eta_( p4.eta() ), phi_( p4.phi() ), mass_( p4.mass() ),
      vertex_( vtx ), pdgId_( pdgId ), status_( status ),
      cachePolarFixed_( false ), cacheCartesianFixed_( false ) {}
   
    LeafCandidate( Charge q, const LorentzVector & p4, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true ) :
      qx3_( q ), pt_( p4.pt() ), eta_( p4.eta() ), phi_( p4.phi() ), mass_( p4.mass() ),
      vertex_( vtx ), pdgId_( pdgId ), status_( status ), p4Cartesian_(p4),
      cachePolarFixed_( false ), cacheCartesianFixed_( true ) {
      if ( integerCharge ) qx3_ *= 3;
    }
    LeafCandidate( Charge q, const PolarLorentzVector & p4, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true ) :
      qx3_( q ), pt_( p4.pt() ), eta_( p4.eta() ), phi_( p4.phi() ), mass_( p4.mass() ),
      vertex_( vtx ), pdgId_( pdgId ), status_( status ), p4Polar_(p4),
      cachePolarFixed_( true ), cacheCartesianFixed_( false ){
      if ( integerCharge ) qx3_ *= 3;
    }
    
    LeafCandidate( Charge q, const GlobalVector & p3, float iEnergy, bool massless, const Point & vtx = Point( 0, 0, 0 ),
           int pdgId = 0, int status = 0, bool integerCharge = true ) :
      qx3_( q ), pt_( p3.perp() ), eta_( p3.eta() ), phi_( p3.phi() ), mass_(massless ? 0. :  dmass(p3,iEnergy) ),
      vertex_( vtx ), pdgId_( pdgId ), status_( status ),  p4Polar_(pt_,eta_,phi_,mass_),  p4Cartesian_(p3.x(),p3.y(),p3.z(), massless ? magd(p3) : iEnergy),
      cachePolarFixed_( true ), cacheCartesianFixed_( true ) {
      if ( integerCharge ) qx3_ *= 3;
    }


    LeafCandidate( Charge q, const GlobalVector & p3, float iEnergy, float imass, const Point & vtx = Point( 0, 0, 0 ),
                   int pdgId = 0, int status = 0, bool integerCharge = true ) :
      qx3_( q ), pt_( p3.perp() ), eta_( p3.eta() ), phi_( p3.phi() ), mass_(imass),
      vertex_( vtx ), pdgId_( pdgId ), status_( status ),  p4Polar_(pt_,eta_,phi_,mass_),  p4Cartesian_(p3.x(),p3.y(),p3.z(), iEnergy),
      cachePolarFixed_( true ), cacheCartesianFixed_( true ) {
      if ( integerCharge ) qx3_ *= 3;
    }


    virtual ~LeafCandidate();
    virtual const_iterator begin() const;
    virtual const_iterator end() const;
    virtual iterator begin();
    virtual iterator end();
    virtual size_t numberOfDaughters() const;
    virtual const Candidate * daughter( size_type ) const;
    virtual size_t numberOfMothers() const;
    virtual const Candidate * mother( size_type ) const;
    virtual Candidate * daughter( size_type );
    virtual Candidate * daughter(const std::string& s );
    virtual const Candidate * daughter(const std::string& s ) const;
    virtual size_t numberOfSourceCandidatePtrs() const { return 0;}
    virtual CandidatePtr sourceCandidatePtr( size_type i ) const {
      return CandidatePtr();
    }

    virtual int charge() const GCC11_FINAL { return qx3_ / 3; }
    virtual void setCharge( Charge q ) GCC11_FINAL { qx3_ = q * 3; }
    virtual int threeCharge() const GCC11_FINAL { return qx3_; }
    virtual void setThreeCharge( Charge qx3 ) GCC11_FINAL { qx3_ = qx3; }
    virtual const LorentzVector & p4() const GCC11_FINAL { cacheCartesian(); return p4Cartesian_; }
    virtual const PolarLorentzVector & polarP4() const GCC11_FINAL { cachePolar(); return p4Polar_; }
    virtual Vector momentum() const GCC11_FINAL { cacheCartesian(); return p4Cartesian_.Vect(); }
    virtual Vector boostToCM() const GCC11_FINAL { cacheCartesian(); return p4Cartesian_.BoostToCM(); }
    virtual double p() const GCC11_FINAL { cacheCartesian(); return p4Cartesian_.P(); }
    virtual double energy() const GCC11_FINAL { cacheCartesian(); return p4Cartesian_.E(); }
    virtual double et() const GCC11_FINAL { cachePolar(); return (pt_<=0) ? 0 :  p4Polar_.Et(); }
    virtual float mass() const GCC11_FINAL { return mass_; }
    virtual float massSqr() const GCC11_FINAL { return mass_ * mass_; }

    virtual double mt() const GCC11_FINAL  { cachePolar(); return p4Polar_.Mt(); }
    virtual double mtSqr() const GCC11_FINAL  { cachePolar(); return p4Polar_.Mt2(); }
    virtual double px() const GCC11_FINAL  { cacheCartesian(); return p4Cartesian_.Px(); }
    virtual double py() const GCC11_FINAL  { cacheCartesian(); return p4Cartesian_.Py(); }
    virtual double pz() const GCC11_FINAL  { cacheCartesian(); return p4Cartesian_.Pz(); }
    virtual float pt() const GCC11_FINAL  { return pt_;}
    virtual float phi() const GCC11_FINAL  { return phi_; }
    virtual double theta() const GCC11_FINAL  { cacheCartesian(); return p4Cartesian_.Theta(); }
    virtual float eta() const GCC11_FINAL  { return eta_; }
    virtual double rapidity() const GCC11_FINAL  { cachePolar(); return p4Polar_.Rapidity(); }
    virtual double y() const GCC11_FINAL  { return rapidity(); }
    virtual void setP4( const LorentzVector & p4 ) GCC11_FINAL  {
      p4Cartesian_ = p4;
      p4Polar_ = p4;
      pt_ = p4Polar_.pt();
      eta_ = p4Polar_.eta();
      phi_ = p4Polar_.phi();
      mass_ = p4Polar_.mass();
      cachePolarFixed_ = true;
      cacheCartesianFixed_ = true;
    }
    virtual void setP4( const PolarLorentzVector & p4 ) GCC11_FINAL  {
      p4Polar_ = p4;
      pt_ = p4Polar_.pt();
      eta_ = p4Polar_.eta();
      phi_ = p4Polar_.phi();
      mass_ = p4Polar_.mass();
      cachePolarFixed_ = true;
      cacheCartesianFixed_ = false;
    }
    virtual void setMass( double m ) GCC11_FINAL  {
      mass_ = m;
      clearCache();
    }
    virtual void setPz( double pz ) GCC11_FINAL  {
      cacheCartesian();
      p4Cartesian_.SetPz(pz);
      p4Polar_ = p4Cartesian_;
      pt_ = p4Polar_.pt();
      eta_ = p4Polar_.eta();
      phi_ = p4Polar_.phi();
      mass_ = p4Polar_.mass();
    }
    virtual const Point & vertex() const { return vertex_; }
    virtual double vx() const  { return vertex_.X(); }
    virtual double vy() const  { return vertex_.Y(); }
    virtual double vz() const  { return vertex_.Z(); }
    virtual void setVertex( const Point & vertex )   { vertex_ = vertex; }

    virtual int pdgId() const GCC11_FINAL  { return pdgId_; }
    // set PDG identifier                                                                 
    virtual void setPdgId( int pdgId ) GCC11_FINAL  { pdgId_ = pdgId; }
    virtual int status() const GCC11_FINAL  { return status_; }
    virtual void setStatus( int status ) GCC11_FINAL  { status_ = status; }
    static const unsigned int longLivedTag;
    virtual void setLongLived() GCC11_FINAL  { status_ |= longLivedTag; }
    virtual bool longLived() const GCC11_FINAL  { return status_ & longLivedTag; }
    static const unsigned int massConstraintTag;
    virtual void setMassConstraint() GCC11_FINAL  { status_ |= massConstraintTag;}
    virtual bool massConstraint() const GCC11_FINAL  { return status_ & massConstraintTag; }

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

    virtual double vertexChi2() const;
    virtual double vertexNdof() const;
    virtual double vertexNormalizedChi2() const;
    virtual double vertexCovariance(int i, int j) const;
    CovarianceMatrix vertexCovariance() const GCC11_FINAL  { CovarianceMatrix m; fillVertexCovariance(m); return m; }
    virtual void fillVertexCovariance(CovarianceMatrix & v) const;
    virtual bool hasMasterClone() const;
    virtual const CandidateBaseRef & masterClone() const;
    virtual bool hasMasterClonePtr() const;
    virtual const CandidatePtr & masterClonePtr() const;

    template<typename Ref>
      Ref masterRef() const { return masterClone().template castTo<Ref>(); }

    template<typename T> T get() const {
      if ( hasMasterClone() ) return masterClone()->get<T>();
      else return reco::get<T>( * this );
    }
    template<typename T, typename Tag> T get() const {
      if ( hasMasterClone() ) return masterClone()->get<T, Tag>();
      else return reco::get<T, Tag>( * this );
    }
    template<typename T> T get( size_type i ) const {
      if ( hasMasterClone() ) return masterClone()->get<T>( i );
      else return reco::get<T>( * this, i );
    }
    template<typename T, typename Tag> T get( size_type i ) const {
      if ( hasMasterClone() ) return masterClone()->get<T, Tag>( i );
      else return reco::get<T, Tag>( * this, i );
    }
    template<typename T> size_type numberOf() const {
      if ( hasMasterClone() ) return masterClone()->numberOf<T>();
      else return reco::numberOf<T>( * this );
    }
    template<typename T, typename Tag> size_type numberOf() const {
      if ( hasMasterClone() ) return masterClone()->numberOf<T, Tag>();
      else return reco::numberOf<T, Tag>( * this );
    }

    template<typename S>
      struct daughter_iterator GCC11_FINAL  {
        typedef boost::filter_iterator<S, const_iterator> type;
      };

    template<typename S>
      typename daughter_iterator<S>::type beginFilter( const S & s ) const {
      return boost::make_filter_iterator(s, begin(), end());
    }
    template<typename S>
      typename daughter_iterator<S>::type endFilter( const S & s ) const {
      return boost::make_filter_iterator(s, end(), end());
    }


    virtual bool isElectron() const;
    virtual bool isMuon() const;
    virtual bool isStandAloneMuon() const;
    virtual bool isGlobalMuon() const;
    virtual bool isTrackerMuon() const;
    virtual bool isCaloMuon() const;
    virtual bool isPhoton() const;
    virtual bool isConvertedPhoton() const;
    virtual bool isJet() const;

  protected:
    Charge qx3_;
    float pt_, eta_, phi_, mass_;
    Point vertex_;
    int pdgId_;
    int status_;
    mutable PolarLorentzVector p4Polar_;
    mutable LorentzVector p4Cartesian_;
    mutable  bool cachePolarFixed_, cacheCartesianFixed_;
    inline void cachePolar() const {
      if ( cachePolarFixed_ ) return;
      p4Polar_ = PolarLorentzVector( pt_, eta_, phi_, mass_ );
      cachePolarFixed_ = true;
    }
    inline void cacheCartesian() const {
      if ( cacheCartesianFixed_ ) return;
      cachePolar();
      p4Cartesian_ = p4Polar_;
      cacheCartesianFixed_ = true;
    }
    inline void clearCache() const {
      cachePolarFixed_ = false;
      cacheCartesianFixed_ = false;
    }
    virtual bool overlap( const Candidate & ) const;
    template<typename, typename, typename> friend struct component;
    friend class ::OverlapChecker;
    friend class ShallowCloneCandidate;
    friend class ShallowClonePtrCandidate;

  private:
    // const iterator implementation
    typedef candidate::const_iterator_imp_specific<daughters> const_iterator_imp_specific;
    // iterator implementation
    typedef candidate::iterator_imp_specific<daughters> iterator_imp_specific;
  };

}

#endif