ROOT » MATH » GENVECTOR » ROOT::Math::PxPyPzE4D<double>

class ROOT::Math::PxPyPzE4D<double>


    Class describing a 4D cartesian coordinate system (x, y, z, t coordinates)
    or momentum-energy vectors stored as (Px, Py, Pz, E).
    The metric used is (-,-,-,+)

    @ingroup GenVector

Function Members (Methods)

public:
~PxPyPzE4D<double>()
ROOT::Math::PxPyPzE4D<double>::ScalarE() const
ROOT::Math::PxPyPzE4D<double>::ScalarEt() const
ROOT::Math::PxPyPzE4D<double>::ScalarEt2() const
ROOT::Math::PxPyPzE4D<double>::ScalarEta() const
voidGetCoordinates(Scalar[] dest) const
voidGetCoordinates(ROOT::Math::PxPyPzE4D<double>::Scalar& px, ROOT::Math::PxPyPzE4D<double>::Scalar& py, ROOT::Math::PxPyPzE4D<double>::Scalar& pz, ROOT::Math::PxPyPzE4D<double>::Scalar& e) const
ROOT::Math::PxPyPzE4D<double>::ScalarM() const
ROOT::Math::PxPyPzE4D<double>::ScalarM2() const
ROOT::Math::PxPyPzE4D<double>::ScalarMag() const
ROOT::Math::PxPyPzE4D<double>::ScalarMag2() const
ROOT::Math::PxPyPzE4D<double>::ScalarMt() const
ROOT::Math::PxPyPzE4D<double>::ScalarMt2() const
voidNegate()
booloperator!=(const ROOT::Math::PxPyPzE4D<double>& rhs) const
ROOT::Math::PxPyPzE4D<double>&operator=(const ROOT::Math::PxPyPzE4D<double>& v)
ROOT::Math::PxPyPzE4D<double>&operator=<ROOT::Math::PxPyPzE4D<double> >(const ROOT::Math::PxPyPzE4D<double>& v)
booloperator==(const ROOT::Math::PxPyPzE4D<double>& rhs) const
ROOT::Math::PxPyPzE4D<double>::ScalarP() const
ROOT::Math::PxPyPzE4D<double>::ScalarP2() const
ROOT::Math::PxPyPzE4D<double>::ScalarPerp() const
ROOT::Math::PxPyPzE4D<double>::ScalarPerp2() const
ROOT::Math::PxPyPzE4D<double>::ScalarPhi() const
ROOT::Math::PxPyPzE4D<double>::ScalarPt() const
ROOT::Math::PxPyPzE4D<double>::ScalarPt2() const
ROOT::Math::PxPyPzE4D<double>::ScalarPx() const
ROOT::Math::PxPyPzE4D<double>PxPyPzE4D<double>()
ROOT::Math::PxPyPzE4D<double>PxPyPzE4D<double>(const ROOT::Math::PxPyPzE4D<double>& v)
ROOT::Math::PxPyPzE4D<double>PxPyPzE4D<double>(const ROOT::Math::PxPyPzE4D<double>& v)
ROOT::Math::PxPyPzE4D<double>PxPyPzE4D<double>(ROOT::Math::PxPyPzE4D<double>::Scalar px, ROOT::Math::PxPyPzE4D<double>::Scalar py, ROOT::Math::PxPyPzE4D<double>::Scalar pz, ROOT::Math::PxPyPzE4D<double>::Scalar e)
ROOT::Math::PxPyPzE4D<double>::ScalarPy() const
ROOT::Math::PxPyPzE4D<double>::ScalarPz() const
ROOT::Math::PxPyPzE4D<double>::ScalarR() const
ROOT::Math::PxPyPzE4D<double>::ScalarRho() const
voidScale(const ROOT::Math::PxPyPzE4D<double>::Scalar& a)
voidSetCoordinates(const Scalar[] src)
voidSetCoordinates(ROOT::Math::PxPyPzE4D<double>::Scalar px, ROOT::Math::PxPyPzE4D<double>::Scalar py, ROOT::Math::PxPyPzE4D<double>::Scalar pz, ROOT::Math::PxPyPzE4D<double>::Scalar e)
voidSetE(ROOT::Math::PxPyPzE4D<double>::Scalar e)
voidSetPx(ROOT::Math::PxPyPzE4D<double>::Scalar px)
voidSetPxPyPzE(ROOT::Math::PxPyPzE4D<double>::Scalar px, ROOT::Math::PxPyPzE4D<double>::Scalar py, ROOT::Math::PxPyPzE4D<double>::Scalar pz, ROOT::Math::PxPyPzE4D<double>::Scalar e)
voidSetPy(ROOT::Math::PxPyPzE4D<double>::Scalar py)
voidSetPz(ROOT::Math::PxPyPzE4D<double>::Scalar pz)
ROOT::Math::PxPyPzE4D<double>::ScalarT() const
ROOT::Math::PxPyPzE4D<double>::Scalart() const
ROOT::Math::PxPyPzE4D<double>::ScalarTheta() const
ROOT::Math::PxPyPzE4D<double>::ScalarX() const
ROOT::Math::PxPyPzE4D<double>::Scalarx() const
ROOT::Math::PxPyPzE4D<double>::ScalarY() const
ROOT::Math::PxPyPzE4D<double>::Scalary() const
ROOT::Math::PxPyPzE4D<double>::ScalarZ() const
ROOT::Math::PxPyPzE4D<double>::Scalarz() const

Data Members

private:
doublefT
doublefX
doublefY
doublefZ

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

void SetCoordinates(const Scalar[] src)
      Set internal data based on an array of 4 Scalar numbers
{ fX=src[0]; fY=src[1]; fZ=src[2]; fT=src[3]; }
void GetCoordinates(Scalar[] dest) const
      get internal data into an array of 4 Scalar numbers
{ dest[0] = fX; dest[1] = fY; dest[2] = fZ; dest[3] = fT; }
void SetCoordinates(ROOT::Math::PxPyPzE4D<double>::Scalar px, ROOT::Math::PxPyPzE4D<double>::Scalar py, ROOT::Math::PxPyPzE4D<double>::Scalar pz, ROOT::Math::PxPyPzE4D<double>::Scalar e)
      Set internal data based on 4 Scalar numbers
{ fX=px; fY=py; fZ=pz; fT=e;}
void GetCoordinates(ROOT::Math::PxPyPzE4D<double>::Scalar& px, ROOT::Math::PxPyPzE4D<double>::Scalar& py, ROOT::Math::PxPyPzE4D<double>::Scalar& pz, ROOT::Math::PxPyPzE4D<double>::Scalar& e) const
      get internal data into 4 Scalar numbers
{ px=fX; py=fY; pz=fZ; e=fT;}
Scalar Px() const
 --------- Coordinates and Coordinate-like Scalar properties -------------
 cartesian (Minkowski)coordinate accessors
{ 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
 other coordinate representation

      squared magnitude of spatial components
{ return fX*fX + fY*fY + fZ*fZ; }
Scalar P() const
      magnitude of spatial components (magnitude of 3-momentum)
{ return std::sqrt(P2()); }
Scalar R() const
{ return P(); }
Scalar M2() const
      vector magnitude squared (or mass squared)
{ return fT*fT - fX*fX - fY*fY - fZ*fZ;}
Scalar Mag2() const
{ return M2(); }
Scalar M() const
      invariant mass
Scalar Mag() const
{ return M(); }
Scalar Pt2() const
       transverse spatial component squared
{ return fX*fX + fY*fY;}
Scalar Perp2() const
{ return Pt2();}
Scalar Pt() const
      Transverse spatial component (P_perp or rho)
{ return std::sqrt(Perp2());}
Scalar Perp() const
{ return Pt();}
Scalar Rho() const
{ return Pt();}
Scalar Mt2() const
       transverse mass squared
{ return fT*fT - fZ*fZ; }
Scalar Mt() const
      transverse mass
Scalar Et2() const
       transverse energy squared
Scalar Et() const
      transverse energy
Scalar Phi() const
      azimuthal angle
Scalar Theta() const
      polar angle
Scalar Eta() const
       pseudorapidity
void SetPx(ROOT::Math::PxPyPzE4D<double>::Scalar px)
 --------- Set Coordinates of this system  ---------------

      set X value
void SetPy(ROOT::Math::PxPyPzE4D<double>::Scalar py)
      set Y value
void SetPz(ROOT::Math::PxPyPzE4D<double>::Scalar pz)
      set Z value
void SetE(ROOT::Math::PxPyPzE4D<double>::Scalar e)
      set T value
void SetPxPyPzE(ROOT::Math::PxPyPzE4D<double>::Scalar px, ROOT::Math::PxPyPzE4D<double>::Scalar py, ROOT::Math::PxPyPzE4D<double>::Scalar pz, ROOT::Math::PxPyPzE4D<double>::Scalar e)
       set all values using cartesian coordinates
void Negate()
 ------ Manipulations -------------

      negate the 4-vector
{ fX = -fX; fY = -fY; fZ = -fZ; fT = -fT;}
void Scale(const ROOT::Math::PxPyPzE4D<double>::Scalar& a)
      scale coordinate values by a scalar quantity a
Scalar x() const
 ============= Compatibility section ==================
 The following make this coordinate system look enough like a CLHEP
 vector that an assignment member template can work with either
{ return fX; }
Scalar y() const
{ return fY; }
Scalar z() const
{ return fZ; }
Scalar t() const
{ return fT; }