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"

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 { return 0; }
    virtual const Candidate * daughter( size_type ) const { return 0; }
    virtual size_t numberOfMothers() const { return 0; }
    virtual const Candidate * mother( size_type ) const { return 0; }
    virtual Candidate * daughter( size_type ) { return 0; }
    virtual Candidate * daughter(const std::string& s ) { return 0; }
    virtual const Candidate * daughter(const std::string& s ) const { return 0; }
    virtual size_t numberOfSourceCandidatePtrs() const { return 0;}
    virtual CandidatePtr sourceCandidatePtr( size_type i ) const {
      static CandidatePtr dummyPtr;
      return dummyPtr;
    }

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

    virtual const LorentzVector & p4() const { cacheCartesian(); return p4Cartesian_; }
    virtual const PolarLorentzVector & polarP4() const { cachePolar(); return p4Polar_; }
    virtual Vector momentum() const { cacheCartesian(); return p4Cartesian_.Vect(); }
    virtual Vector boostToCM() const { cacheCartesian(); return p4Cartesian_.BoostToCM(); }
    virtual double p() const { cacheCartesian(); return p4Cartesian_.P(); }
    virtual double energy() const { cacheCartesian(); return p4Cartesian_.E(); }
    virtual double et() const { cachePolar(); return p4Polar_.Et(); }
    virtual double mass() const { return mass_; }
    virtual double massSqr() const { return mass_ * mass_; }
    virtual double mt() const { cachePolar(); return p4Polar_.Mt(); }
    virtual double mtSqr() const { cachePolar(); return p4Polar_.Mt2(); }
    virtual double px() const { cacheCartesian(); return p4Cartesian_.Px(); }
    virtual double py() const { cacheCartesian(); return p4Cartesian_.Py(); }
    virtual double pz() const { cacheCartesian(); return p4Cartesian_.Pz(); }
    virtual double pt() const { return ref_->pt(); } 
    virtual double phi() const { return ref_->phi(); }
    virtual double theta() const { return ref_->theta(); }
    virtual double eta() const { return ref_->eta(); }
    virtual double rapidity() const { cachePolar(); return p4Polar_.Rapidity(); }
    virtual double y() const { return rapidity(); }

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

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


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

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

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

    template<typename C> C get() const {
      if ( hasMasterClone() ) return masterClone()->get<C>();
      else return reco::get<C>( * this );
    }
    template<typename C, typename Tag> C get() const {
      if ( hasMasterClone() ) return masterClone()->get<C, Tag>();
      else return reco::get<C, Tag>( * this );
    }
    template<typename C> C get( size_type i ) const {
      if ( hasMasterClone() ) return masterClone()->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()->get<C, Tag>( i );
      else return reco::get<C, Tag>( * this, i );
    }
    template<typename C> size_type numberOf() const {
      if ( hasMasterClone() ) return masterClone()->numberOf<C>();
      else return reco::numberOf<C>( * this );
    }
    template<typename C, typename Tag> size_type numberOf() const {
      if ( hasMasterClone() ) return masterClone()->numberOf<C, Tag>();
      else return reco::numberOf<C, Tag>( * this );
    }

    template<typename S>
      struct daughter_iterator {
        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 { return false; }
    virtual bool isMuon() const { return false; }
    virtual bool isStandAloneMuon() const { return false; }
    virtual bool isGlobalMuon() const { return false; }
    virtual bool isTrackerMuon() const { return false; }
    virtual bool isCaloMuon() const { return false; }
    virtual bool isPhoton() const { return false; }
    virtual bool isConvertedPhoton() const { return false; }
    virtual bool isJet() const { 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;

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