LeafRefCandidateT.h

Go to the documentation of this file.

#ifndef Candidate_LeafRefCandidateT_h
#define Candidate_LeafRefCandidateT_h

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

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

#include "DataFormats/Common/interface/BoolCache.h"

namespace reco {
  
  template < class T >
  class LeafRefCandidateT : 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;

    LeafRefCandidateT() : 
      mass_(0), 
      cachePolarFixed_( false ) { }
    // constructor from T                                                        
    explicit LeafRefCandidateT( const T & c, float m) :
      ref_(c),
      mass_( m ),
      cachePolarFixed_( false ), cacheCartesianFixed_( false ) {}

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

    virtual int charge() const GCC11_FINAL  { return ref_->charge(); }
    virtual int pdgId() const GCC11_FINAL  { return 0; }

    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 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 ref_->pt(); } 
    virtual float phi() const GCC11_FINAL  { return ref_->phi(); }
    virtual double theta() const GCC11_FINAL  { return ref_->theta(); }
    virtual float eta() const GCC11_FINAL  { return ref_->eta(); }
    virtual double rapidity() const GCC11_FINAL  { cachePolar(); return p4Polar_.Rapidity(); }
    virtual double y() const GCC11_FINAL  { return rapidity(); }

    virtual void setMass( double m ) GCC11_FINAL  {
      mass_ = m;
      clearCache();
    }

    virtual const Point & vertex() const GCC11_FINAL  { return ref_->vertex(); }
    virtual double vx() const GCC11_FINAL  { return ref_->vx(); }
    virtual double vy() const GCC11_FINAL  { return ref_->vy(); }
    virtual double vz() const GCC11_FINAL  { return ref_->vz(); }


    virtual LeafRefCandidateT<T> * clone() const GCC11_FINAL  {
      return new LeafRefCandidateT<T>( *this );
    }

                     
    virtual bool hasMasterClone() const GCC11_FINAL  { return false; }
    virtual const CandidateBaseRef & masterClone() const GCC11_FINAL  { 
      static const CandidateBaseRef dummyRef; return dummyRef; 
    }
    virtual bool hasMasterClonePtr() const GCC11_FINAL  { return false; }
    virtual const CandidatePtr & masterClonePtr() const GCC11_FINAL  { 
      static const CandidatePtr dummyPtr; return dummyPtr; 
    }

    template<typename Ref>
      Ref masterRef() const { Ref dummyRef; return dummyRef; }

    template<typename C> C get() const {
      if ( hasMasterClone() ) return masterClone()->template get<C>();
      else return reco::get<C>( * this );
    }
    template<typename C, typename Tag> C get() const {
      if ( hasMasterClone() ) return masterClone()->template get<C, Tag>();
      else return reco::get<C, Tag>( * this );
    }
    template<typename C> C get( size_type i ) const {
      if ( hasMasterClone() ) return masterClone()->template get<C>( i );
      else return reco::get<C>( * this, i );
    }
    template<typename C, typename Tag> C get( size_type i ) const {
      if ( hasMasterClone() ) return masterClone()->template get<C, Tag>( i );
      else return reco::get<C, Tag>( * this, i );
    }
    template<typename C> size_type numberOf() const {
      if ( hasMasterClone() ) return masterClone()->template numberOf<C>();
      else return reco::numberOf<C>( * this );
    }
    template<typename C, typename Tag> size_type numberOf() const {
      if ( hasMasterClone() ) return masterClone()->template numberOf<C, Tag>();
      else return reco::numberOf<C, 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 GCC11_FINAL  { return false; }
    virtual bool isMuon() const GCC11_FINAL  { return false; }
    virtual bool isStandAloneMuon() const GCC11_FINAL  { return false; }
    virtual bool isGlobalMuon() const GCC11_FINAL  { return false; }
    virtual bool isTrackerMuon() const GCC11_FINAL  { return false; }
    virtual bool isCaloMuon() const GCC11_FINAL  { return false; }
    virtual bool isPhoton() const GCC11_FINAL  { return false; }
    virtual bool isConvertedPhoton() const GCC11_FINAL  { return false; }
    virtual bool isJet() const GCC11_FINAL  { return false; }

  protected:
    T    ref_;
    float mass_;
    mutable PolarLorentzVector p4Polar_;
    mutable LorentzVector p4Cartesian_;
    mutable  edm::BoolCache cachePolarFixed_, cacheCartesianFixed_;
    inline void cachePolar() const {
      if ( cachePolarFixed_ ) return;
      p4Polar_ = PolarLorentzVector( ref_->pt(), ref_->eta(), ref_->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;
    virtual bool overlap( const LeafRefCandidateT & ) const;
    template<typename, typename, typename> friend struct component;
    friend class ::OverlapChecker;
    friend class ShallowCloneCandidate;
    friend class ShallowClonePtrCandidate;

    CMS_CLASS_VERSION(11)

  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;


                                        
    virtual void setCharge( Charge q ) GCC11_FINAL  { return; }                                         
    virtual int threeCharge() const GCC11_FINAL  { return 0; }
    virtual void setThreeCharge( Charge qx3 ) GCC11_FINAL  { return; }
    virtual void setP4( const LorentzVector & p4 ) GCC11_FINAL  {
      return;
    }
    virtual void setP4( const PolarLorentzVector & p4 ) GCC11_FINAL  {
      return;
    }
    virtual void setPz( double pz ) GCC11_FINAL  {
      return;
    }                            
    virtual void setVertex( const Point & vertex ) GCC11_FINAL  { return; }
    virtual void setPdgId( int pdgId ) GCC11_FINAL  { return; }                                              
    virtual int status() const GCC11_FINAL  { return 0; }                                      
    virtual void setStatus( int status ) GCC11_FINAL  { return; }
    static const unsigned int longLivedTag;                                               
    virtual void setLongLived() GCC11_FINAL  { return; }                                      
    virtual bool longLived() const GCC11_FINAL  { return false; }
    static const unsigned int massConstraintTag;
    virtual void setMassConstraint() GCC11_FINAL  { return;}
    virtual bool massConstraint() const GCC11_FINAL  { return false; }  
    virtual double vertexChi2() const GCC11_FINAL  { return 0.; }
    virtual double vertexNdof() const GCC11_FINAL  { return 0.; }
    virtual double vertexNormalizedChi2() const GCC11_FINAL  { return 0.; }
    virtual double vertexCovariance(int i, int j) const GCC11_FINAL  { return 0.; }
    CovarianceMatrix vertexCovariance() const GCC11_FINAL  { CovarianceMatrix m; return m; }
    virtual void fillVertexCovariance(CovarianceMatrix & v) const GCC11_FINAL  { return ; }
    
  };



  template<class T>
  Candidate::const_iterator LeafRefCandidateT<T>::begin() const  { 
    return const_iterator( new const_iterator_imp_specific ); 
  }

  template<class T>
  Candidate::const_iterator LeafRefCandidateT<T>::end() const   { 
    return  const_iterator( new const_iterator_imp_specific ); 
  }

  template<class T>
  Candidate::iterator LeafRefCandidateT<T>::begin()   { 
    return iterator( new iterator_imp_specific ); 
  }
  
  template<class T>
  Candidate::iterator LeafRefCandidateT<T>::end()   { 
    return iterator( new iterator_imp_specific ); 
  }
  
  
  template<class T>
  bool LeafRefCandidateT<T>::overlap( const Candidate & o ) const  { 
    return  p4() == o.p4() && vertex() == o.vertex() && charge() == o.charge();
  }
  
  
  template<class T>
  bool LeafRefCandidateT<T>::overlap( const LeafRefCandidateT & o ) const   { 
    return  ref_ == o.ref_;
  }



}

#endif