PackedGenParticle.h

Go to the documentation of this file.

#ifndef __AnalysisDataFormats_PackedGenParticle_h__
#define __AnalysisDataFormats_PackedGenParticle_h__

#include "DataFormats/HepMCCandidate/interface/GenParticleFwd.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
#include "DataFormats/HepMCCandidate/interface/GenStatusFlags.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/Common/interface/RefVector.h"
#include "DataFormats/Common/interface/Association.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"
#include "DataFormats/VertexReco/interface/Vertex.h"
#include "DataFormats/Math/interface/deltaPhi.h" 
/* #include "DataFormats/Math/interface/PtEtaPhiMass.h" */

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

    typedef unsigned int index;

  PackedGenParticle()
    : p4_(0,0,0,0), p4c_(0,0,0,0), vertex_(0,0,0),  pdgId_(0), charge_(0), unpacked_(false) { }
  explicit PackedGenParticle( const reco::GenParticle & c)
    : p4_(c.pt(), c.eta(), c.phi(), c.mass()), p4c_(p4_), vertex_(0,0,0), pdgId_(c.pdgId()), charge_(c.charge()), mother_(c.motherRef(0)), unpacked_(true),
      statusFlags_(c.statusFlags()) { pack(); }
  explicit PackedGenParticle( const reco::GenParticle & c, const edm::Ref<reco::GenParticleCollection> &  mother)
    : p4_(c.pt(), c.eta(), c.phi(), c.mass()), p4c_(p4_), vertex_(0,0,0), pdgId_(c.pdgId()), charge_(c.charge()), mother_(mother), unpacked_(true),
      statusFlags_(c.statusFlags()) { pack(); }

    
    virtual ~PackedGenParticle();
    virtual size_t numberOfDaughters() const;
    virtual const reco::Candidate * daughter( size_type ) const;
    virtual size_t numberOfMothers() const;
    virtual const reco::Candidate * mother( size_type ) const;
    const reco::GenParticleRef & motherRef() const { return mother_; }

    virtual reco::Candidate * daughter( size_type );
    virtual reco::Candidate * daughter(const std::string& s );
    virtual const reco::Candidate * daughter(const std::string& s ) const;
    virtual size_t numberOfSourceCandidatePtrs() const {return 0;}
    virtual reco::CandidatePtr sourceCandidatePtr( size_type i ) const {
      return reco::CandidatePtr();
    }

    virtual int charge() const {
    return charge_; 
    }
    virtual void setCharge( int charge) {charge_=charge;}
    virtual int threeCharge() const {return charge()*3;}
    virtual void setThreeCharge( int threecharge) {}
    virtual const LorentzVector & p4() const { if (!unpacked_) unpack(); return p4c_; }  
    virtual const PolarLorentzVector & polarP4() const { if (!unpacked_) unpack(); return p4_; }
    virtual Vector momentum() const  { if (!unpacked_) unpack(); return p4c_.Vect(); }
    virtual Vector boostToCM() const { if (!unpacked_) unpack(); return p4c_.BoostToCM(); }
    virtual double p() const { if (!unpacked_) unpack(); return p4c_.P(); }
    virtual double energy() const { if (!unpacked_) unpack(); return p4c_.E(); }
    double et() const { return (pt()<=0) ? 0 : p4c_.Et(); }
    double et2() const { return (pt()<=0) ? 0 : p4c_.Et2(); }
    virtual double mass() const { if (!unpacked_) unpack(); return p4_.M(); }
    virtual double massSqr() const { if (!unpacked_) unpack(); return p4_.M()*p4_.M(); }

    virtual double mt() const { if (!unpacked_) unpack(); return p4_.Mt(); }
    virtual double mtSqr() const { if (!unpacked_) unpack(); return p4_.Mt2(); }
    virtual double px() const { if (!unpacked_) unpack(); return p4c_.Px(); }
    virtual double py() const { if (!unpacked_) unpack(); return p4c_.Py(); }
    virtual double pz() const { if (!unpacked_) unpack(); return p4c_.Pz(); }
    virtual double pt() const { if (!unpacked_) unpack(); return p4_.Pt();}
    virtual double phi() const { if (!unpacked_) unpack(); return p4_.Phi(); }
    virtual double theta() const { if (!unpacked_) unpack(); return p4_.Theta(); }
    virtual double eta() const { if (!unpacked_) unpack(); return p4_.Eta(); }
    virtual double rapidity() const { if (!unpacked_) unpack(); return p4_.Rapidity(); }
    virtual double y() const { if (!unpacked_) unpack(); return p4_.Rapidity(); }
    virtual void setP4( const LorentzVector & p4 ) { 
        unpack(); // changing px,py,pz changes also mapping between dxy,dz and x,y,z
        p4_ = PolarLorentzVector(p4.Pt(), p4.Eta(), p4.Phi(), p4.M());
        pack();
    }
    virtual void setP4( const PolarLorentzVector & p4 ) { 
        unpack(); // changing px,py,pz changes also mapping between dxy,dz and x,y,z
        p4_ = p4; 
        pack();
    }
    virtual void setMass( double m ) {
      if (!unpacked_) unpack(); 
      p4_ = PolarLorentzVector(p4_.Pt(), p4_.Eta(), p4_.Phi(), m); 
      pack();
    }
    virtual void setPz( double pz ) {
      unpack(); // changing px,py,pz changes also mapping between dxy,dz and x,y,z
      p4c_ = LorentzVector(p4c_.Px(), p4c_.Py(), pz, p4c_.E());
      p4_  = PolarLorentzVector(p4c_.Pt(), p4c_.Eta(), p4c_.Phi(), p4c_.M());
      pack();
    }
    virtual const Point & vertex() const { return vertex_; }//{ if (fromPV_) return Point(0,0,0); else return Point(0,0,100); }
    virtual double vx() const  {  return vertex_.X(); }//{ return 0; }
    virtual double vy() const  {  return vertex_.Y(); }//{ return 0; }
    virtual double vz() const  {  return vertex_.Z(); }//{ if (fromPV_) return 0; else return 100; }
    virtual void setVertex( const Point & vertex ) { vertex_ = vertex;  }

    enum PVAssoc { NoPV=0, PVLoose=1, PVTight=2, PVUsedInFit=3 } ;


    virtual float dxy() const { unpack(); return dxy_; }
    virtual float dz()  const { unpack(); return dz_; }
    virtual float dxy(const Point &p) const ;
    virtual float dz(const Point &p)  const ;


    virtual int pdgId() const   { return pdgId_; }
    // set PDG identifier                                                                 
    virtual void setPdgId( int pdgId )   { pdgId_ = pdgId; }
    virtual int status() const   { return 1; } /*FIXME*/
    virtual void setStatus( int status ) {} /*FIXME*/
    static const unsigned int longLivedTag = 0; /*FIXME*/
    virtual void setLongLived() {} /*FIXME*/
    virtual bool longLived() const;
    static const unsigned int massConstraintTag = 0; /*FIXME*/ 
    virtual void setMassConstraint() {} /*FIXME*/
    virtual bool massConstraint() const;

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

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

    virtual const reco::CandidatePtr & masterClonePtr() const;

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

    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;
    
    const reco::GenStatusFlags &statusFlags() const { return statusFlags_; }
    reco::GenStatusFlags &statusFlags() { return statusFlags_; }
    
    //basic set of gen status flags accessible directly here
    //the rest accessible through statusFlags()
    //(see GenStatusFlags.h for their meaning)
    
    //these are robust, generator-independent functions for categorizing
    //mainly final state particles, but also intermediate hadrons/taus
    
    //is particle prompt (not from hadron, muon, or tau decay) and final state
    bool isPromptFinalState() const { return status()==1 && statusFlags_.isPrompt(); }
        
    //this particle is a direct decay product of a prompt tau and is final state
    //(eg an electron or muon from a leptonic decay of a prompt tau)
    bool isDirectPromptTauDecayProductFinalState() const { return status()==1 && statusFlags_.isDirectPromptTauDecayProduct(); }
    
    //these are generator history-dependent functions for tagging particles
    //associated with the hard process
    //Currently implemented for Pythia 6 and Pythia 8 status codes and history   
    //and may not have 100% consistent meaning across all types of processes
    //Users are strongly encouraged to stick to the more robust flags above,
    //as well as the expanded set available in GenStatusFlags.h
    
    //this particle is the final state direct descendant of a hard process particle  
    bool fromHardProcessFinalState() const { return status()==1 && statusFlags_.fromHardProcess(); }
        
    //this particle is a direct decay product of a hardprocess tau and is final state
    //(eg an electron or muon from a leptonic decay of a tau from the hard process)
    bool isDirectHardProcessTauDecayProductFinalState() const { return status()==1 && statusFlags_.isDirectHardProcessTauDecayProduct(); }
        

  protected:
    uint16_t packedPt_, packedY_, packedPhi_, packedM_;
    void pack(bool unpackAfterwards=true) ;
    void unpack() const ;
 
    mutable PolarLorentzVector p4_;
    mutable LorentzVector p4c_;
    mutable Point vertex_;
    mutable float dxy_, dz_, dphi_;
    int pdgId_;
    int8_t charge_;
    reco::GenParticleRef mother_;
    // is the momentum p4 unpacked
    mutable bool unpacked_;
    //status flags
    reco::GenStatusFlags statusFlags_;

    virtual bool overlap( const reco::Candidate & ) const;
    template<typename, typename, typename> friend struct component;
    friend class ::OverlapChecker;
    friend class ShallowCloneCandidate;
    friend class ShallowClonePtrCandidate;

  };

  typedef std::vector<pat::PackedGenParticle> PackedGenParticleCollection;
  typedef edm::Ref<pat::PackedGenParticleCollection> PackedGenParticleRef;
  typedef edm::RefVector<pat::PackedGenParticleCollection> PackedGenParticleRefVector;
}

#endif