include/Rivet/ParticleBase.hh

0001 #ifndef RIVET_ParticleBase_HH
0002 #define RIVET_ParticleBase_HH
0003
0004 #include "Rivet/Config/RivetCommon.hh"
0005 #include "Rivet/Jet.fhh"
0006 #include "Rivet/Tools/Cuts.fhh"
0007 #include "Rivet/Math/Vectors.hh"
0008
0009 namespace Rivet {
0010
0011
0012   /// @brief Base class for particle-like things like Particle and Jet
0013   class ParticleBase {
0014   public:
0015
0016     /// Default constructor
0017     ParticleBase() { }
0018
0019     /// Virtual destructor
0020     virtual ~ParticleBase() { }
0021
0022
0023     // /// @name Constituent accessors
0024     // /// @{
0025
0026     // /// @todo Can't do this because a) ParticleBase is pure-virtual; b) inheritance causality for Particle... urk
0027     // virtual const vector<ParticleBase>& constituents() const = 0;
0028     // virtual const vector<ParticleBase>& rawConstituents() const = 0;
0029
0030     // /// @}
0031
0032
0033     /// @name Effective momentum accessors
0034     /// @{
0035
0036     /// Get equivalent single momentum four-vector (const).
0037     virtual const FourMomentum& momentum() const = 0;
0038     /// Get equivalent single momentum four-vector (const) (alias).
0039     const FourMomentum& mom() const { return momentum(); };
0040
0041     /// Cast operator for conversion to FourMomentum
0042     operator const FourMomentum& () const { return momentum(); }
0043
0044     /// @}
0045
0046
0047     /// @name Convenience access to the effective 4-vector properties
0048     /// @{
0049
0050     /// Get the energy directly.
0051     double E() const { return momentum().E(); }
0052     /// Get the energy directly (alias).
0053     double energy() const { return momentum().E(); }
0054
0055     /// Get the energy-squared.
0056     double E2() const { return momentum().E2(); }
0057     /// Get the energy-squared (alias).
0058     double energy2() const { return momentum().E2(); }
0059
0060     /// Get the \f$ p_T \f$ directly.
0061     double pt() const { return momentum().pt(); }
0062     /// Get the \f$ p_T \f$ directly (alias).
0063     double pT() const { return pt(); }
0064     /// Get the \f$ p_T \f$ directly (alias).
0065     double perp() const { return pt(); }
0066
0067     /// Get the \f$ p_T^2 \f$ directly.
0068     double pt2() const { return momentum().pt2(); }
0069     /// Get the \f$ p_T^2 \f$ directly (alias).
0070     double pT2() const { return pt2(); }
0071     /// Get the \f$ p_T^2 \f$ directly (alias).
0072     double perp2() const { return pt2(); }
0073
0074     /// Get the \f$ E_T \f$ directly.
0075     double Et() const { return momentum().Et(); }
0076     /// Get the \f$ E_T^2 \f$ directly.
0077     double Et2() const { return momentum().Et2(); }
0078
0079     /// Get the mass directly.
0080     double mass() const { return momentum().mass(); }
0081     /// Get the mass**2 directly.
0082     double mass2() const { return momentum().mass2(); }
0083
0084     /// Get the \f$ \eta \f$ directly.
0085     double pseudorapidity() const { return momentum().eta(); }
0086     /// Get the \f$ \eta \f$ directly (alias).
0087     double eta() const { return momentum().eta(); }
0088     /// Get the \f$ |\eta| \f$ directly.
0089     double abspseudorapidity() const { return momentum().abspseudorapidity(); }
0090     /// Get the \f$ |\eta| \f$ directly (alias).
0091     double abseta() const { return momentum().abseta(); }
0092
0093     /// Get the \f$ y \f$ directly.
0094     double rapidity() const { return momentum().rapidity(); }
0095     /// Get the \f$ y \f$ directly (alias).
0096     double rap() const { return momentum().rapidity(); }
0097     /// Get the \f$ |y| \f$ directly.
0098     double absrapidity() const { return momentum().absrapidity(); }
0099     /// Get the \f$ |y| \f$ directly (alias).
0100     double absrap() const { return momentum().absrap(); }
0101
0102     /// Azimuthal angle \f$ \phi \f$.
0103     double azimuthalAngle(const PhiMapping mapping=ZERO_2PI) const { return momentum().azimuthalAngle(mapping); }
0104     /// Get the \f$ \phi \f$ directly.
0105     double phi(const PhiMapping mapping=ZERO_2PI) const { return momentum().phi(mapping); }
0106
0107     /// Get the 3-momentum directly.
0108     ThreeMomentum p3() const { return momentum().vector3(); }
0109     /// Get the 3-momentum magnitude directly.
0110     double p() const { return momentum().p(); }
0111     /// Get the 3-momentum magnitude-squared directly.
0112     double p2() const { return momentum().p2(); }
0113
0114     /// Get the transverse 3-momentum directly.
0115     Vector3 ptvec() const { return momentum().ptvec(); }
0116     /// Get the transverse 3-momentum directly.
0117     Vector3 pTvec() const { return momentum().pTvec(); }
0118
0119     /// x component of momentum.
0120     double px() const { return momentum().x(); }
0121     /// y component of momentum.
0122     double py() const { return momentum().y(); }
0123     /// z component of momentum.
0124     double pz() const { return momentum().z(); }
0125
0126     /// x component of momentum, squared.
0127     double px2() const { return momentum().x2(); }
0128     /// y component of momentum, squared.
0129     double py2() const { return momentum().y2(); }
0130     /// z component of momentum, squared.
0131     double pz2() const { return momentum().z2(); }
0132
0133     /// Angle subtended by the 3-vector and the z-axis.
0134     double polarAngle() const { return momentum().polarAngle(); }
0135     /// Synonym for polarAngle.
0136     double theta() const { return momentum().theta(); }
0137
0138     /// Angle between this vector and another
0139     double angle(const ParticleBase& v) const { return momentum().angle(v.momentum()); }
0140     /// Angle between this vector and another
0141     double angle(const FourVector& v) const { return momentum().angle(v); }
0142     /// Angle between this vector and another (3-vector)
0143     double angle(const Vector3& v3) const { return momentum().angle(v3); }
0144
0145     /// Lorentz dot product between this 4-vector and another
0146     double dot(const ParticleBase& v) const { return momentum().dot(v.momentum()); }
0147     /// Angle between this 4-vector and another
0148     double dot(const FourVector& v) const { return momentum().dot(v); }
0149
0150     /// @}
0151
0152   };
0153
0154
0155   /// @name deltaR, deltaEta, deltaPhi functions specifically for Particle/Jet arguments
0156   /// @{
0157
0158   inline double deltaR(const ParticleBase& p1, const ParticleBase& p2,
0159                        RapScheme scheme = PSEUDORAPIDITY) {
0160     return deltaR(p1.momentum(), p2.momentum(), scheme);
0161   }
0162
0163   inline double deltaR(const ParticleBase& p, const FourMomentum& v,
0164                        RapScheme scheme = PSEUDORAPIDITY) {
0165     return deltaR(p.momentum(), v, scheme);
0166   }
0167
0168   inline double deltaR(const ParticleBase& p, const FourVector& v,
0169                        RapScheme scheme = PSEUDORAPIDITY) {
0170     return deltaR(p.momentum(), v, scheme);
0171   }
0172
0173   inline double deltaR(const ParticleBase& p, const Vector3& v) {
0174     return deltaR(p.momentum(), v);
0175   }
0176
0177   inline double deltaR(const ParticleBase& p, double eta, double phi) {
0178     return deltaR(p.momentum(), eta, phi);
0179   }
0180
0181   inline double deltaR(const FourMomentum& v, const ParticleBase& p,
0182                        RapScheme scheme = PSEUDORAPIDITY) {
0183     return deltaR(v, p.momentum(), scheme);
0184   }
0185
0186   inline double deltaR(const FourVector& v, const ParticleBase& p,
0187                        RapScheme scheme = PSEUDORAPIDITY) {
0188     return deltaR(v, p.momentum(), scheme);
0189   }
0190
0191   inline double deltaR(const Vector3& v, const ParticleBase& p) {
0192     return deltaR(v, p.momentum());
0193   }
0194
0195   inline double deltaR(double eta, double phi, const ParticleBase& p) {
0196     return deltaR(eta, phi, p.momentum());
0197   }
0198
0199
0200   inline double deltaPhi(const ParticleBase& p1, const ParticleBase& p2, bool sign=false) {
0201     return deltaPhi(p1.momentum(), p2.momentum(), sign);
0202   }
0203
0204   inline double deltaPhi(const ParticleBase& p, const FourMomentum& v, bool sign=false) {
0205     return deltaPhi(p.momentum(), v, sign);
0206   }
0207
0208   inline double deltaPhi(const ParticleBase& p, const FourVector& v, bool sign=false) {
0209     return deltaPhi(p.momentum(), v, sign);
0210   }
0211
0212   inline double deltaPhi(const ParticleBase& p, const Vector3& v, bool sign=false) {
0213     return deltaPhi(p.momentum(), v, sign);
0214   }
0215
0216   inline double deltaPhi(const ParticleBase& p, double phi, bool sign=false) {
0217     return deltaPhi(p.momentum(), phi, sign);
0218   }
0219
0220   inline double deltaPhi(const FourMomentum& v, const ParticleBase& p, bool sign=false) {
0221     return deltaPhi(v, p.momentum(), sign);
0222   }
0223
0224   inline double deltaPhi(const FourVector& v, const ParticleBase& p, bool sign=false) {
0225     return deltaPhi(v, p.momentum(), sign);
0226   }
0227
0228   inline double deltaPhi(const Vector3& v, const ParticleBase& p, bool sign=false) {
0229     return deltaPhi(v, p.momentum(), sign);
0230   }
0231
0232   inline double deltaPhi(double phi, const ParticleBase& p, bool sign=false) {
0233     return deltaPhi(phi, p.momentum(), sign);
0234   }
0235
0236
0237   inline double deltaEta(const ParticleBase& p1, const ParticleBase& p2) {
0238     return deltaEta(p1.momentum(), p2.momentum());
0239   }
0240
0241   inline double deltaEta(const ParticleBase& p, const FourMomentum& v) {
0242     return deltaEta(p.momentum(), v);
0243   }
0244
0245   inline double deltaEta(const ParticleBase& p, const FourVector& v) {
0246     return deltaEta(p.momentum(), v);
0247   }
0248
0249   inline double deltaEta(const ParticleBase& p, const Vector3& v) {
0250     return deltaEta(p.momentum(), v);
0251   }
0252
0253   inline double deltaEta(const ParticleBase& p, double eta) {
0254     return deltaEta(p.momentum(), eta);
0255   }
0256
0257   inline double deltaEta(const FourMomentum& v, const ParticleBase& p) {
0258     return deltaEta(v, p.momentum());
0259   }
0260
0261   inline double deltaEta(const FourVector& v, const ParticleBase& p) {
0262     return deltaEta(v, p.momentum());
0263   }
0264
0265   inline double deltaEta(const Vector3& v, const ParticleBase& p) {
0266     return deltaEta(v, p.momentum());
0267   }
0268
0269   inline double deltaEta(double eta, const ParticleBase& p) {
0270     return deltaEta(eta, p.momentum());
0271   }
0272
0273
0274   inline double deltaRap(const ParticleBase& p1, const ParticleBase& p2) {
0275     return deltaRap(p1.momentum(), p2.momentum());
0276   }
0277
0278   inline double deltaRap(const ParticleBase& p, const FourMomentum& v) {
0279     return deltaRap(p.momentum(), v);
0280   }
0281
0282   inline double deltaRap(const ParticleBase& p, double y) {
0283     return deltaRap(p.momentum(), y);
0284   }
0285
0286   inline double deltaRap(const FourMomentum& v, const ParticleBase& p) {
0287     return deltaRap(v, p.momentum());
0288   }
0289
0290   inline double deltaRap(double y, const ParticleBase& p) {
0291     return deltaRap(y, p.momentum());
0292   }
0293
0294   /// @}
0295
0296
0297 }
0298
0299 #endif