#ifndef ROOT_Math_GenVector_PxPyPzE4D
#define ROOT_Math_GenVector_PxPyPzE4D 1
#include "Math/GenVector/etaMax.h"
#include "Math/GenVector/GenVector_exception.h"
#include <cmath>
namespace ROOT {
namespace Math {
template <class ScalarType = double>
class PxPyPzE4D {
public :
typedef ScalarType Scalar;
PxPyPzE4D() : fX(0), fY(0), fZ(0), fT(0) { }
PxPyPzE4D(Scalar x, Scalar y, Scalar z, Scalar t) :
fX(x), fY(y), fZ(z), fT(t) { }
template <class CoordSystem>
explicit PxPyPzE4D(const CoordSystem & v) :
fX( v.x() ), fY( v.y() ), fZ( v.z() ), fT( v.t() ) { }
void SetCoordinates( const Scalar src[] )
{ fX=src[0]; fY=src[1]; fZ=src[2]; fT=src[3]; }
void GetCoordinates( Scalar dest[] ) const
{ dest[0] = fX; dest[1] = fY; dest[2] = fZ; dest[3] = fT; }
void SetCoordinates(Scalar x, Scalar y, Scalar z, Scalar t)
{ fX=x; fY=y; fZ=z; fT=t;}
void GetCoordinates(Scalar& x, Scalar& y, Scalar& z, Scalar& t) const
{ x=fX; y=fY; z=fZ; t=fT;}
Scalar Px() const { return fX;}
Scalar Py() const { return fY;}
Scalar Pz() const { return fZ;}
Scalar E() const { return fT;}
Scalar X() const { return fX;}
Scalar Y() const { return fY;}
Scalar Z() const { return fZ;}
Scalar T() const { return fT;}
Scalar P2() const { return fX*fX + fY*fY + fZ*fZ; }
Scalar P() const { return std::sqrt(P2()); }
Scalar R() const { return P(); }
Scalar M2() const { return fT*fT - fX*fX - fY*fY - fZ*fZ;}
Scalar Mag2() const { return M2(); }
Scalar M() const {
Scalar mm = M2();
if (mm >= 0) {
return std::sqrt(mm);
} else {
GenVector_exception e ("PxPyPzE4D::M() - Tachyonic:\n"
" P^2 > E^2 so the mass would be imaginary");
Throw(e);
return -std::sqrt(-mm);
}
}
Scalar Mag() const { return M(); }
Scalar Pt2() const { return fX*fX + fY*fY;}
Scalar Perp2() const { return Pt2();}
Scalar Pt() const { return std::sqrt(Perp2());}
Scalar Perp() const { return Pt();}
Scalar Rho() const { return Pt();}
Scalar Mt2() const { return fT*fT - fZ*fZ; }
Scalar Mt() const {
Scalar mm = Mt2();
if (mm >= 0) {
return std::sqrt(mm);
} else {
GenVector_exception e ("PxPyPzE4D::Mt() - Tachyonic:\n"
" Pz^2 > E^2 so the transverse mass would be imaginary");
Throw(e);
return -std::sqrt(-mm);
}
}
Scalar Et2() const {
Scalar pt2 = Pt2();
return pt2 == 0 ? 0 : fT*fT * pt2/( pt2 + fZ*fZ );
}
Scalar Et() const {
Scalar etet = Et2();
return fT < 0.0 ? -std::sqrt(etet) : std::sqrt(etet);
}
Scalar Phi() const {
return (fX == 0.0 && fY == 0.0) ? 0.0 : std::atan2(fY,fX);
}
Scalar Theta() const {
return (fX == 0.0 && fY == 0.0 && fZ == 0.0) ? 0.0 : std::atan2(Pt(),fZ);
}
Scalar Eta() const {
Scalar rho = Pt();
if (rho > 0) {
Scalar z_scaled(fZ/rho);
return std::log(z_scaled+std::sqrt(z_scaled*z_scaled+1));
} else if (fZ==0) {
return 0;
} else if (fZ>0) {
return fZ + etaMax<Scalar>( );
} else {
return fZ - etaMax<Scalar>( );
}
}
void SetPx( Scalar x) {
fX = x;
}
void SetPy( Scalar y) {
fY = y;
}
void SetPz( Scalar z) {
fZ = z;
}
void SetE( Scalar t) {
fT = t;
}
void Negate( ) { fX = -fX; fY = -fY; fZ = -fZ; fT = -fT;}
void Scale( const Scalar & a) {
fX *= a;
fY *= a;
fZ *= a;
fT *= a;
}
template <class AnyCoordSystem>
PxPyPzE4D & operator = (const AnyCoordSystem & v) {
fX = v.x();
fY = v.y();
fZ = v.z();
fT = v.t();
return *this;
}
bool operator == (const PxPyPzE4D & rhs) const {
return fX == rhs.fX && fY == rhs.fY && fZ == rhs.fZ && fT == rhs.fT;
}
bool operator != (const PxPyPzE4D & rhs) const {return !(operator==(rhs));}
Scalar x() const { return X(); }
Scalar y() const { return Y(); }
Scalar z() const { return Z(); }
Scalar t() const { return E(); }
#if defined(__MAKECINT__) || defined(G__DICTIONARY)
void SetPt(Scalar pt);
void SetEta(Scalar eta);
void SetPhi(Scalar phi);
void SetM(Scalar m);
#endif
private:
ScalarType fX;
ScalarType fY;
ScalarType fZ;
ScalarType fT;
};
}
}
#if defined(__MAKECINT__) || defined(G__DICTIONARY)
#include "Math/GenVector/PtEtaPhiE4D.h"
#include "Math/GenVector/PtEtaPhiM4D.h"
namespace ROOT {
namespace Math {
template <class ScalarType>
void PxPyPzE4D<ScalarType>::SetPt(Scalar pt) {
GenVector_exception e("PxPyPzE4D::SetPt() is not supposed to be called");
Throw(e);
PtEtaPhiE4D<Scalar> v(*this); v.SetPt(pt); *this = PxPyPzE4D<Scalar>(v);
}
template <class ScalarType>
void PxPyPzE4D<ScalarType>::SetEta(Scalar eta) {
GenVector_exception e("PxPyPzE4D::SetEta() is not supposed to be called");
Throw(e);
PtEtaPhiE4D<Scalar> v(*this); v.SetEta(eta); *this = PxPyPzE4D<Scalar>(v);
}
template <class ScalarType>
void PxPyPzE4D<ScalarType>::SetPhi(Scalar phi) {
GenVector_exception e("PxPyPzE4D::SetPhi() is not supposed to be called");
Throw(e);
PtEtaPhiE4D<Scalar> v(*this); v.SetPhi(phi); *this = PxPyPzE4D<Scalar>(v);
}
template <class ScalarType>
void PxPyPzE4D<ScalarType>::SetM(Scalar m) {
GenVector_exception e("PxPyPzE4D::SetM() is not supposed to be called");
Throw(e);
PtEtaPhiM4D<Scalar> v(*this); v.SetM(m);
*this = PxPyPzE4D<Scalar>(v);
}
}
}
#endif // endif __MAKE__CINT || G__DICTIONARY
#endif // ROOT_Math_GenVector_PxPyPzE4D
ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.