Quick Links: ROOT Homepage Class Index Class Hierarchy

Sections: class description function members data members class charts

ROOT » MATH » GENVECTOR » ROOT::Math::PxPyPzM4D<Double32_t>

class ROOT::Math::PxPyPzM4D<Double32_t>


    Class describing a 4D coordinate system
    or momentum-energy vectors stored as (Px, Py, Pz, M).
    This system is useful to describe ultra-relativistic particles
    (like electrons at LHC) to avoid numerical errors evaluating the mass
    when E >>> m
    The metric used is (-,-,-,+)
    Spacelike particles (M2 < 0) are described with negative mass values,
    but in this case m2 must alwasy be less than P2 to preserve a positive value of E2

    @ingroup GenVector

This class is also known as (typedefs to this class)

ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<Double32_t> >::CoordinateType

Function Members (Methods)

public:

	~PxPyPzM4D<Double32_t>()
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	E() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	E2() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Et() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Et2() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Eta() const
void	GetCoordinates(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar* dest) const
void	GetCoordinates(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& px, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& py, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& pz, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& m) const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	M() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	M2() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Mag() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Mag2() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Mt() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Mt2() const
void	Negate()
bool	operator!=(const ROOT::Math::PxPyPzM4D<Double32_t>& rhs) const
ROOT::Math::PxPyPzM4D<Double32_t>&	operator=(const ROOT::Math::PxPyPzM4D<Double32_t>& v)
bool	operator==(const ROOT::Math::PxPyPzM4D<Double32_t>& rhs) const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	P() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	P2() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Perp() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Perp2() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Phi() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Pt() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Pt2() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Px() const
ROOT::Math::PxPyPzM4D<Double32_t>	PxPyPzM4D<Double32_t>()
ROOT::Math::PxPyPzM4D<Double32_t>	PxPyPzM4D<Double32_t>(const ROOT::Math::PxPyPzM4D<Double32_t>& v)
ROOT::Math::PxPyPzM4D<Double32_t>	PxPyPzM4D<Double32_t>(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar px, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar py, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar pz, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar m)
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Py() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Pz() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	R() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Rho() const
void	Scale(const ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& a)
void	SetCoordinates(const ROOT::Math::PxPyPzM4D<Double32_t>::Scalar* src)
void	SetCoordinates(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar px, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar py, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar pz, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar m)
void	SetE(Double32_t energy)
void	SetEta(Double32_t eta)
void	SetM(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar m)
void	SetPhi(Double32_t phi)
void	SetPt(Double32_t pt)
void	SetPx(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar px)
void	SetPxPyPzE(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar px, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar py, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar pz, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar e)
void	SetPy(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar py)
void	SetPz(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar pz)
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	T() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	t() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Theta() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	X() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	x() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Y() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	y() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	Z() const
ROOT::Math::PxPyPzM4D<Double32_t>::Scalar	z() const

private:

void	RestrictNegMass()

Data Members

private:

Double32_t	fM
Double32_t	fX
Double32_t	fY
Double32_t	fZ

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

void SetCoordinates(const ROOT::Math::PxPyPzM4D<Double32_t>::Scalar* src)

      Set internal data based on an array of 4 Scalar numbers

void GetCoordinates(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar* dest) const

      get internal data into an array of 4 Scalar numbers

{ dest[0] = fX; dest[1] = fY; dest[2] = fZ; dest[3] = fM; }

void SetCoordinates(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar px, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar py, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar pz, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar m)

      Set internal data based on 4 Scalar numbers

void GetCoordinates(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& px, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& py, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& pz, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar& m) const

      get internal data into 4 Scalar numbers

{ px=fX; py=fY; pz=fZ; m=fM;}

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 M() const

{ return fM; }

Scalar X() const

{ return fX;}

Scalar Y() const

{ return fY;}

Scalar Z() const

{ return fZ;}

Scalar E() const

 other coordinate representation

      Energy

{ return std::sqrt(E2() ); }

Scalar T() const

{ return E();}

Scalar P2() const

      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)
      In case of negative mass (spacelike particles return negative values)

Scalar Mag2() const

{ return M2(); }

Scalar Mag() const

{ return M(); }

Scalar E2() const

      energy squared

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 E2() - 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::PxPyPzM4D<Double32_t>::Scalar px)

 --------- Set Coordinates of this system  ---------------

      set X value

void SetPy(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar py)

      set Y value

void SetPz(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar pz)

      set Z value

void SetM(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar m)

      set T value

void SetPxPyPzE(ROOT::Math::PxPyPzM4D<Double32_t>::Scalar px, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar py, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar pz, ROOT::Math::PxPyPzM4D<Double32_t>::Scalar e)

       set all values

void Negate()

 ------ Manipulations -------------

      negate the 4-vector -  Note that the energy cannot be negate (would need an additional data member)
      therefore negate will work only on the spatial components.
      One would need to use negate only with vectors having the energy as data members

void Scale(const ROOT::Math::PxPyPzM4D<Double32_t>::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 X(); }

Scalar y() const

{ return Y(); }

Scalar z() const

{ return Z(); }

Scalar t() const

{ return E(); }

void SetPt(Double32_t pt)

 ====== Set member functions for coordinates in other systems =======

void SetEta(Double32_t eta)

void SetPhi(Double32_t phi)

void SetE(Double32_t energy)

void RestrictNegMass()

 restrict the value of negative mass to avoid unphysical negative E2 values
 M2 must be less than P2 for the tachionic particles - otherwise use positive values