ParticleBase.h

Go to the documentation of this file.

#ifndef SimDataFormats_ParticleBase_h
#define SimDataFormats_ParticleBase_h

#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "Rtypes.h"

class ParticleBase
{
public:
    typedef int Charge;
    typedef math::XYZTLorentzVectorD LorentzVector;
    typedef math::PtEtaPhiMLorentzVector PolarLorentzVector;
    typedef math::XYZPointD Point;
    typedef math::XYZVectorD Vector;
    ParticleBase() : cachePolarFixed_( false ), cacheCartesianFixed_( false ) { }
    ParticleBase( Charge q, const LorentzVector & p4, const Point & vertex = 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_( vertex ), pdgId_( pdgId ), status_( status ),
            cachePolarFixed_( false ), cacheCartesianFixed_( false )
    {
        if ( integerCharge ) qx3_ *= 3;
    }
    ParticleBase( Charge q, const PolarLorentzVector & p4, const Point & vertex = 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_( vertex ), pdgId_( pdgId ), status_( status ),
            cachePolarFixed_( false ), cacheCartesianFixed_( false )
    {
        if ( integerCharge ) qx3_ *= 3;
    }
    virtual ~ParticleBase() { }
    int charge() const
    {
        return qx3_ / 3;
    }
    void setCharge( Charge q )
    {
        qx3_ = q * 3;
    }
    int threeCharge() const
    {
        return qx3_;
    }
    void setThreeCharge( Charge qx3 )
    {
        qx3_ = qx3;
    }
    const LorentzVector & p4() const
    {
        cacheCartesian();
        return p4Cartesian_;
    }
    const PolarLorentzVector & polarP4() const
    {
        cachePolar();
        return p4Polar_;
    }
    Vector momentum() const
    {
        cacheCartesian();
        return p4Cartesian_.Vect();
    }
    Vector boostToCM() const
    {
        cacheCartesian();
        return p4Cartesian_.BoostToCM();
    }
    double p() const
    {
        cacheCartesian();
        return p4Cartesian_.P();
    }
    double energy() const
    {
        cacheCartesian();
        return p4Cartesian_.E();
    }
    double et() const
    {
        cachePolar();
        return p4Polar_.Et();
    }
    double mass() const
    {
        return mass_;
    }
    double massSqr() const
    {
        return mass_ * mass_;
    }
    double mt() const
    {
        cachePolar();
        return p4Polar_.Mt();
    }
    double mtSqr() const
    {
        cachePolar();
        return p4Polar_.Mt2();
    }
    double px() const
    {
        cacheCartesian();
        return p4Cartesian_.Px();
    }
    double py() const
    {
        cacheCartesian();
        return p4Cartesian_.Py();
    }
    double pz() const
    {
        cacheCartesian();
        return p4Cartesian_.Pz();
    }
    double pt() const
    {
        return pt_;
    }
    double phi() const
    {
        return phi_;
    }
    double theta() const
    {
        cacheCartesian();
        return p4Cartesian_.Theta();
    }
    double eta() const
    {
        return eta_;
    }
    double rapidity() const
    {
        cachePolar();
        return p4Polar_.Rapidity();
    }
    double y() const
    {
        return rapidity();
    }
    void setP4( const LorentzVector & p4 )
    {
        p4Cartesian_ = p4;
        p4Polar_ = p4;
        pt_ = p4Polar_.pt();
        eta_ = p4Polar_.eta();
        phi_ = p4Polar_.phi();
        mass_ = p4Polar_.mass();
        cachePolarFixed_ = true;
        cacheCartesianFixed_ = true;
    }
    void setP4( const PolarLorentzVector & p4 )
    {
        p4Polar_ = p4;
        pt_ = p4Polar_.pt();
        eta_ = p4Polar_.eta();
        phi_ = p4Polar_.phi();
        mass_ = p4Polar_.mass();
        cachePolarFixed_ = true;
        cacheCartesianFixed_ = false;
    }
    void setMass( double m )
    {
        mass_ = m;
        clearCache();
    }
    void setPz( double pz )
    {
        cacheCartesian();
        p4Cartesian_.SetPz(pz);
        p4Polar_ = p4Cartesian_;
        pt_ = p4Polar_.pt();
        eta_ = p4Polar_.eta();
        phi_ = p4Polar_.phi();
        mass_ = p4Polar_.mass();
    }
    const Point & vertex() const
    {
        return vertex_;
    }
    double vx() const
    {
        return vertex_.X();
    }
    double vy() const
    {
        return vertex_.Y();
    }
    double vz() const
    {
        return vertex_.Z();
    }
    void setVertex( const Point & vertex )
    {
        vertex_ = vertex;
    }
    int pdgId() const
    {
        return pdgId_;
    }
    // set PDG identifier
    void setPdgId( int pdgId )
    {
        pdgId_ = pdgId;
    }
    int status() const
    {
        return status_;
    }
    void setStatus( int status )
    {
        status_ = status;
    }
    static const unsigned int longLivedTag;
    void setLongLived()
    {
        status_ |= longLivedTag;
    }
    bool longLived() const
    {
        return status_ & longLivedTag;
    }

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;
    }
};

#endif