Vector classes (2D, 3D and 4D / Lorentz vector) and their transformations.

These classes represent vectors and their operations and transformations, such as rotations and Lorentz transformations, in two, three and four dimensions. The 4D space-time is used for physics vectors representing relativistic particles in Minkowski-space. These vectors are different from Linear Algebra vectors or std::vector which describe generic N-dimensional vectors.

Hint: the most commonly used Lorentz vector class is ROOT::Math::PtEtaPhiMVector, a typedef to ROOT::Math::LorentzVector < ROOT::Math::PtEtaPhiM4D < double > >.

Points and Vector concept

Mathematically, vectors and points are two distinct concepts. They have different transformations: vectors can only be rotated, while points can be rotated or translated. You can add two vectors but not two points, and the difference between two points is a vector. We then distinguish for the 2 and 3 dimensional case, between points and vectors, modeling them with different classes:

ROOT::Math::DisplacementVector2D and ROOT::Math::DisplacementVector3D describe 2- and 3-component direction and magnitude vectors, not rooted at any particular point;
ROOT::Math::PositionVector2D and ROOT::Math::PositionVector3D model points in 2 and 3 dimensions.

ROOT::Math::LorentzVector models 4D space-time vectors. There is no class for a 4D point.

Coordinate Systems

Generic Coordinate System

The vector classes are based on a generic type of coordinate system, expressed as a template parameter of the class. Various classes exist to describe the various coordinates systems:

2D coordinate system classes:
- ROOT::Math::Cartesian2D, based on (x,y) ;
- ROOT::Math::Polar2D, based on (r, phi) ;
3D coordinate system classes:
- ROOT::Math::Cartesian3D, based on (x,y,z);
- ROOT::Math::Polar3D, based on (r, theta, phi);
- ROOT::Math::Cylindrical3D, based on (rho, z, phi)
- ROOT::Math::CylindricalEta3D, based on (rho, eta, phi);
4D coordinate system classes:
- ROOT::Math::PxPyPzE4D, based on based on (px,py,pz,E);
- ROOT::Math::PxPyPzM4D, based on based on (px,py,pz,M);
- ROOT::Math::PtEtaPhiE4D, based on based on (pt,eta,phi,E);
- ROOT::Math::PtEtaPhiM4D, based on based on (pt,eta,phi,M);

The angle theta is defined between [0, \(\pi\)] and phi between [- \(\pi\), \(\pi\)]. The angles are expressed in radians. The eta component is known as pseudo-rapidity.

Users can define the Vectors according to the coordinate type which is most efficient for their use. Transformations between the various coordinate systems are available through copy constructors or the assignment operator =. The coordinate system classes are templated on the scalar type for maximum flexibility, and to minimize memory usage for some use cases.

Coordinate System Tag

The 2D and 3D point and vector classes can be associated to a tag defining the coordinate system. This can be used to distinguish between vectors of different coordinate systems like global or local vectors. The coordinate system tag is a template parameter of the ROOT::Math::DisplacementVector3D (and ROOT::Math::DisplacementVector2D) and ROOT::Math::PositionVector3D (and ROOT::Math::PositionVector2D) classes. A default tag, ROOT::Math::DefaultCoordinateSystemTag, exists for users who don't need this functionality.

Concrete Vector typedefs

To avoid exposing templated parameters to the users, typedefs are defined for all types of vectors based an doubles and floats. The table below lists the double versions; the float counterpart ends on an extra F, such as ROOT::Math::XYPointF instead of ROOT::Math::XYPoint.

Point2D

Type definitions for points in two dimensions, based on ROOT::Math::PositionVector2D, are defined by Math/Point2D.h:

ROOT::Math::XYPoint vector based on x,y coordinates (cartesian)
ROOT::Math::Polar2DPoint vector based on r,phi coordinates (polar)

Vector2D

Type definitions for vectors in two dimensions, based on ROOT::Math::DisplacementVector2D, are defined by Math/Vector2D.h:

ROOT::Math::XYVector vector based on x,y coordinates (cartesian)
ROOT::Math::Polar2DVector vector based on r,phi coordinates (polar)

Point3D

Type definitions for points in three dimensions, based on ROOT::Math::PositionVector3D, are defined by Math/Point3D.h:

ROOT::Math::XYZPoint point based on x,y,z coordinates (cartesian)
ROOT::Math::Polar3DPoint point based on r,theta,phi coordinates (polar)
ROOT::Math::RhoZPhiPoint point based on rho,z,phi coordinates (cylindrical using z)
ROOT::Math::RhoEtaPhiPoint point based on rho,eta,phi coordinates (cylindrical using eta instead of z)

Vector3D

Type definitions for vectors in three dimensions, based on ROOT::Math::DisplacementVector3D, are defined by Math/Vector3D.h:

ROOT::Math::XYZVector vector based on x,y,z coordinates (cartesian)
ROOT::Math::Polar3DVector vector based on r,theta,phi coordinates (polar)
ROOT::Math::RhoZPhiVector vector based on rho, z,phi coordinates (cylindrical)
ROOT::Math::RhoEtaPhiVector vector based on rho,eta,phi coordinates (cylindrical using eta instead of z)

LorentzVector

Type definitions for Lorentz vectors in four dimensions, based on ROOT::Math::LorentzVector, are defined by Math/Vector4D.h:

ROOT::Math::XYZTVector vector based on x,y,z,t coordinates (cartesian)
ROOT::Math::PtEtaPhiEVector vector based on pt (rho),eta,phi and E (t) coordinates
ROOT::Math::PtEtaPhiMVector vector based on pt (rho),eta,phi and M (t) coordinates
ROOT::Math::PxPyPzMVector vector based on px,py,pz and M (mass) coordinates
ROOT::Math::PxPyPzEVector vector based on px,py,pz and E (energy) coordinates

The metric used for any such LorentzVector is (-,-,-,+).

Operations

Utility Functions for all Vectors

Check the functions below, as well as in ROOT::Math::VectorUtil for non-member functions such as DeltaR, Angle, boost.

Constructors and Assignment

A vector can be constructed from its coordinate representation:

ROOT::Math::PtEtaPhiMVector v1(10. /*pt*/, 0.1 /*eta*/, 0.24 /*phi*/, 5 /*M*/);

ROOT::Detail::TRangeCast

Definition TCollection.h:311

v1

@ v1

Definition rootcling_impl.cxx:3685

In addition, the vector classes can be constructed from any object that implements the accessors x(), y() and z(). This can be a vector using a different coordinate system, or even an object from a different package as long as it implements the required signatures. One such vector type is CLHEP's Hep3Vector:

XYZVector v1(1,2,3);
RhoEtaPhiVector r2(v1);
CLHEP::Hep3Vector q(1,2,3);
XYZVector v3(q)

Arithmetic Operations

The following operations are possible between vector classes, even of different coordinate system types:

v1 += v2;
v1 -= v2;
v1 = - v2;
v1 *= a;
v1 /= a;
v2 = a * v1;
v2 = v1 / a;
v2 = v1 * a;
v3 = v1 + v2;
v3 = v1 - v2;

Note that the multiplication between two vectors using the operator * is not supported because it is ambiguous.

Note: For the vectors using the 4D coordinate systems based on mass instead of energy (such as **ROOT::Math::PxPyPzM4D** or **ROOT::Math::PtEtaPhiM4D**) the unary operator - (negation) doesn't perform a 4-vector negation. Instead, it negates only the spatial components, which might result in unintuive behaviours (for instance, for PxPyPzM4D coordinate system, \(\textbf{v}+ \left(-\textbf{v}\right) \neq \textbf{v} -\textbf{v}\)).

Other Methods

The vector classes support methods for:

computation of the dot product via Dot(),
computation of the cross product via Cross(),
construction of a unit vector via Unit().

Transformations

The transformations are modeled using simple (non-template) classes, using double as the scalar type to avoid too large numerical errors. The transformations are grouped in Rotations (in 3 dimensions), Lorentz transformations. Each group has several members which may model physically equivalent transformations but with different internal representations. Transformation classes can operate on all type of vectors using the operator() or the operator * and the transformations can also be combined via the operator *. In more detail the transformations available are:

3D Rotations

ROOT::Math::Rotation3D, rotation described by a 3x3 matrix of doubles
ROOT::Math::EulerAngles rotation described by the three Euler angles (phi, theta and psi) following the GoldStein definition.
ROOT::Math::RotationZYX rotation described by three angles defining a rotation first along the Z axis, then along the rotated Y' axis and then along the rotated X'' axis.
ROOT::Math::AxisAngle, rotation described by a vector (axis) and an angle
ROOT::Math::Quaternion, rotation described by a quaternion (4 numbers)
ROOT::Math::RotationX, specialized rotation along the X axis
ROOT::Math::RotationY, specialized rotation along the Y axis
ROOT::Math::RotationZ, specialized rotation along the Z axis

3D Transformation

ROOT::Math::Translation3D, (only translation) described by a 3D vector
ROOT::Math::Transform3D, (rotations and then translation) described by a 3x4 matrix (12 numbers)

Lorentz Rotation

ROOT::Math::LorentzRotation , 4D rotation (3D rotation plus a boost) described by a 4x4 matrix
ROOT::Math::Boost, a Lorentz boost in an arbitrary direction and described by a 4x4 symmetric matrix (10 numbers)
ROOT::Math::BoostX, a boost in the X axis direction
ROOT::Math::BoostY, a boost in the Y axis direction
ROOT::Math::BoostZ, a boost in the Z axis direction

Compatibility with CLHEP Vector classes

For compatibility with CLHEP, the vector classes can be constructed easily from a CLHEP Hep3Vector or HepLorentzVector, by using a template constructor, which requires only that the classes implement the accessors x(), y() and z() (and t() for HepLorentzVector). The vector classes also provide member function with the same naming convention as CLHEP for the most used functions like x(), y() and z().

Additional Documentation

A more detailed description of all the GenVector classes is available in this document.

Namespaces
namespace	ROOT::Math::VectorUtil
	Global Helper functions for generic Vector classes.

Classes
class	ROOT::Math::AxisAngle
	AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotation around that axis. More...

class	ROOT::Math::Boost
	Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matrix. More...

class	ROOT::Math::BoostX
	Class representing a Lorentz Boost along the X axis, by beta. More...

class	ROOT::Math::BoostY
	Class representing a Lorentz Boost along the Y axis, by beta. More...

class	ROOT::Math::BoostZ
	Class representing a Lorentz Boost along the Z axis, by beta. More...

class	ROOT::Math::Cartesian2D< T >
	Class describing a 2D cartesian coordinate system (x, y coordinates) More...

class	ROOT::Math::Cartesian3D< T >
	Class describing a 3D cartesian coordinate system (x, y, z coordinates) More...

class	ROOT::Math::Cylindrical3D< T >
	Class describing a cylindrical coordinate system based on rho, z and phi. More...

class	ROOT::Math::CylindricalEta3D< T >
	Class describing a cylindrical coordinate system based on eta (pseudorapidity) instead of z. More...

class	ROOT::Math::DefaultCoordinateSystemTag
	DefaultCoordinateSystemTag Default tag for identifying any coordinate system. More...

class	ROOT::Math::DisplacementVector2D< CoordSystem, Tag >
	Class describing a generic displacement vector in 2 dimensions. More...

class	ROOT::Math::DisplacementVector3D< CoordSystem, Tag >
	Class describing a generic displacement vector in 3 dimensions. More...

class	ROOT::Math::EulerAngles
	EulerAngles class describing rotation as three angles (Euler Angles). More...

class	ROOT::Math::GlobalCoordinateSystemTag
	Tag for identifying vectors based on a global coordinate system. More...

class	ROOT::Math::LocalCoordinateSystemTag
	Tag for identifying vectors based on a local coordinate system. More...

class	ROOT::Math::LorentzRotation
	Lorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix. More...

class	ROOT::Math::LorentzVector< CoordSystem >
	Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate system for the spatial vector part. More...

class	ROOT::Math::Impl::Plane3D< T >
	Class describing a geometrical plane in 3 dimensions. More...

class	ROOT::Math::Polar2D< T >
	Class describing a polar 2D coordinate system based on r and phi Phi is restricted to be in the range [-PI,PI) More...

class	ROOT::Math::Polar3D< T >
	Class describing a polar coordinate system based on r, theta and phi Phi is restricted to be in the range [-PI,PI) More...

class	ROOT::Math::PositionVector2D< CoordSystem, Tag >
	Class describing a generic position vector (point) in 2 dimensions. More...

class	ROOT::Math::PositionVector3D< CoordSystem, Tag >
	Class describing a generic position vector (point) in 3 dimensions. More...

class	ROOT::Math::PtEtaPhiE4D< ScalarType >
	Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho, phi, eta , T) The metric used is (-,-,-,+). More...

class	ROOT::Math::PtEtaPhiM4D< ScalarType >
	Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used is (-,-,-,+). More...

class	ROOT::Math::PxPyPzE4D< ScalarType >
	Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors stored as (Px, Py, Pz, E). More...

class	ROOT::Math::PxPyPzM4D< ScalarType >
	Class describing a 4D coordinate system or momentum-energy vectors stored as (Px, Py, Pz, M). More...

class	ROOT::Math::Quaternion
	Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k). More...

class	ROOT::Math::Rotation3D
	Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix. More...

class	ROOT::Math::RotationX
	Rotation class representing a 3D rotation about the X axis by the angle of rotation. More...

class	ROOT::Math::RotationY
	Rotation class representing a 3D rotation about the Y axis by the angle of rotation. More...

class	ROOT::Math::RotationZ
	Rotation class representing a 3D rotation about the Z axis by the angle of rotation. More...

class	ROOT::Math::RotationZYX
	Rotation class with the (3D) rotation represented by angles describing first a rotation of an angle phi (yaw) about the Z axis, followed by a rotation of an angle theta (pitch) about the Y axis, followed by a third rotation of an angle psi (roll) about the X axis. More...

class	ROOT::Math::Impl::Transform3D< T >
	Basic 3D Transformation class describing a rotation and then a translation The internal data are a 3D rotation data (represented as a 3x3 matrix) and a 3D vector data. More...

class	ROOT::Math::Impl::Translation3D< T >
	Class describing a 3 dimensional translation. More...

Functions
template<class CoordSystem >
LorentzVector< CoordSystem >::Scalar	ROOT::ROOT_MATH_ARCH::Acoplanarity (LorentzVector< CoordSystem > const &pp, LorentzVector< CoordSystem > const &pm)
	pair (p+ p-) acoplanarity `alpha = 1 - \|phi+ - phi-\|/pi`.

template<class CoordSystem >
LorentzVector< CoordSystem >::Scalar	ROOT::Math::Acoplanarity (LorentzVector< CoordSystem > const &pp, LorentzVector< CoordSystem > const &pm)
	pair (p+ p-) acoplanarity `alpha = 1 - \|phi+ - phi-\|/pi`.

template<class Vector1 , class Vector2 >
double	ROOT::ROOT_MATH_ARCH::VectorUtil::Angle (const Vector1 &v1, const Vector2 &v2)
	Find Angle between two vectors.

template<class Vector1 , class Vector2 >
double	ROOT::Math::VectorUtil::Angle (const Vector1 &v1, const Vector2 &v2)
	Find Angle between two vectors.

template<class CoordSystem >
LorentzVector< CoordSystem >::Scalar	ROOT::ROOT_MATH_ARCH::AsymmetryScalar (LorentzVector< CoordSystem > const &pp, LorentzVector< CoordSystem > const &pm)
	pair (p+ p-) scalar asymmetry `As = \|\|Pt+\| - \|Pt-\|/\|\|Pt+\| + \|Pt-\|\|`.

template<class CoordSystem >
LorentzVector< CoordSystem >::Scalar	ROOT::Math::AsymmetryScalar (LorentzVector< CoordSystem > const &pp, LorentzVector< CoordSystem > const &pm)
	pair (p+ p-) scalar asymmetry `As = \|\|Pt+\| - \|Pt-\|/\|\|Pt+\| + \|Pt-\|\|`.

template<class CoordSystem >
LorentzVector< CoordSystem >::Scalar	ROOT::ROOT_MATH_ARCH::AsymmetryVectorial (LorentzVector< CoordSystem > const &pp, LorentzVector< CoordSystem > const &pm)
	pair (p+ p-) vectorial asymmetry `Av = \|Pt+ - Pt-\|/\|Pt+ + Pt-\|`.

template<class CoordSystem >
LorentzVector< CoordSystem >::Scalar	ROOT::Math::AsymmetryVectorial (LorentzVector< CoordSystem > const &pp, LorentzVector< CoordSystem > const &pm)
	pair (p+ p-) vectorial asymmetry `Av = \|Pt+ - Pt-\|/\|Pt+ + Pt-\|`.

template<class LVector , class BoostVector >
LVector	ROOT::ROOT_MATH_ARCH::VectorUtil::boost (const LVector &v, const BoostVector &b)
	Boost a generic Lorentz Vector class using a generic 3D Vector class describing the boost The only requirement on the vector is that implements the X(), Y(), Z(), T() and SetXYZT methods.

template<class LVector , class BoostVector >
LVector	ROOT::Math::VectorUtil::boost (const LVector &v, const BoostVector &b)
	Boost a generic Lorentz Vector class using a generic 3D Vector class describing the boost The only requirement on the vector is that implements the X(), Y(), Z(), T() and SetXYZT methods.

template<class LVector , class T >
LVector	ROOT::ROOT_MATH_ARCH::VectorUtil::boostX (const LVector &v, T beta)
	Boost a generic Lorentz Vector class along the X direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() and SetXYZT methods.

template<class LVector , class T >
LVector	ROOT::Math::VectorUtil::boostX (const LVector &v, T beta)
	Boost a generic Lorentz Vector class along the X direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() and SetXYZT methods.

template<class LVector >
LVector	ROOT::ROOT_MATH_ARCH::VectorUtil::boostY (const LVector &v, double beta)
	Boost a generic Lorentz Vector class along the Y direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() methods and be constructed from x,y,z,t values The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned.

template<class LVector >
LVector	ROOT::Math::VectorUtil::boostY (const LVector &v, double beta)
	Boost a generic Lorentz Vector class along the Y direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() methods and be constructed from x,y,z,t values The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned.

template<class LVector >
LVector	ROOT::ROOT_MATH_ARCH::VectorUtil::boostZ (const LVector &v, double beta)
	Boost a generic Lorentz Vector class along the Z direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() methods and be constructed from x,y,z,t values The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned.

template<class LVector >
LVector	ROOT::Math::VectorUtil::boostZ (const LVector &v, double beta)
	Boost a generic Lorentz Vector class along the Z direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() methods and be constructed from x,y,z,t values The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned.

template<class Vector1 , class Vector2 >
double	ROOT::ROOT_MATH_ARCH::VectorUtil::CosTheta (const Vector1 &v1, const Vector2 &v2)
	Find CosTheta Angle between two generic 3D vectors pre-requisite: vectors implement the X(), Y() and Z()

template<class Vector1 , class Vector2 >
double	ROOT::Math::VectorUtil::CosTheta (const Vector1 &v1, const Vector2 &v2)
	Find CosTheta Angle between two generic 3D vectors pre-requisite: vectors implement the X(), Y() and Z()

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaPhi (const Vector1 &v1, const Vector2 &v2)
	Find aximutal Angle difference between two generic vectors ( v2.Phi() - v1.Phi() ) The only requirements on the Vector classes is that they implement the Phi() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::Math::VectorUtil::DeltaPhi (const Vector1 &v1, const Vector2 &v2)
	Find aximutal Angle difference between two generic vectors ( v2.Phi() - v1.Phi() ) The only requirements on the Vector classes is that they implement the Phi() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaR (const Vector1 &v1, const Vector2 &v2)
	Find difference in pseudorapidity (Eta) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Eta() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::Math::VectorUtil::DeltaR (const Vector1 &v1, const Vector2 &v2)
	Find difference in pseudorapidity (Eta) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Eta() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaR2 (const Vector1 &v1, const Vector2 &v2)
	Find square of the difference in pseudorapidity (Eta) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Eta() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::Math::VectorUtil::DeltaR2 (const Vector1 &v1, const Vector2 &v2)
	Find square of the difference in pseudorapidity (Eta) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Eta() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaR2RapidityPhi (const Vector1 &v1, const Vector2 &v2)
	Find square of the difference in true rapidity (y) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Rapidity() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::Math::VectorUtil::DeltaR2RapidityPhi (const Vector1 &v1, const Vector2 &v2)
	Find square of the difference in true rapidity (y) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Rapidity() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaRapidityPhi (const Vector1 &v1, const Vector2 &v2)
	Find difference in Rapidity (y) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Rapidity() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::Math::VectorUtil::DeltaRapidityPhi (const Vector1 &v1, const Vector2 &v2)
	Find difference in Rapidity (y) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Rapidity() method.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::ROOT_MATH_ARCH::VectorUtil::InvariantMass (const Vector1 &v1, const Vector2 &v2)
	return the invariant mass of two LorentzVector The only requirement on the LorentzVector is that they need to implement the X() , Y(), Z() and E() methods.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::Math::VectorUtil::InvariantMass (const Vector1 &v1, const Vector2 &v2)
	return the invariant mass of two LorentzVector The only requirement on the LorentzVector is that they need to implement the X() , Y(), Z() and E() methods.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::ROOT_MATH_ARCH::VectorUtil::InvariantMass2 (const Vector1 &v1, const Vector2 &v2)
	Returns the square of what InvariantMass(const Vector1&, const Vector2&) would return.

template<class Vector1 , class Vector2 >
Vector1::Scalar	ROOT::Math::VectorUtil::InvariantMass2 (const Vector1 &v1, const Vector2 &v2)
	Returns the square of what InvariantMass(const Vector1&, const Vector2&) would return.

template<class Matrix , class CoordSystem , class U >
DisplacementVector3D< CoordSystem, U >	ROOT::ROOT_MATH_ARCH::VectorUtil::Mult (const Matrix &m, const DisplacementVector3D< CoordSystem, U > &v)
	Multiplications of a generic matrices with a DisplacementVector3D of any coordinate system.

template<class Matrix , class CoordSystem , class U >
DisplacementVector3D< CoordSystem, U >	ROOT::Math::VectorUtil::Mult (const Matrix &m, const DisplacementVector3D< CoordSystem, U > &v)
	Multiplications of a generic matrices with a DisplacementVector3D of any coordinate system.

template<class CoordSystem , class Matrix >
LorentzVector< CoordSystem >	ROOT::ROOT_MATH_ARCH::VectorUtil::Mult (const Matrix &m, const LorentzVector< CoordSystem > &v)
	Multiplications of a generic matrices with a LorentzVector described in any coordinate system.

template<class CoordSystem , class Matrix >
LorentzVector< CoordSystem >	ROOT::Math::VectorUtil::Mult (const Matrix &m, const LorentzVector< CoordSystem > &v)
	Multiplications of a generic matrices with a LorentzVector described in any coordinate system.

template<class Matrix , class CoordSystem , class U >
PositionVector3D< CoordSystem, U >	ROOT::ROOT_MATH_ARCH::VectorUtil::Mult (const Matrix &m, const PositionVector3D< CoordSystem, U > &p)
	Multiplications of a generic matrices with a generic PositionVector Assume that the matrix implements the operator( i,j) and that it has at least 3 columns and 3 rows.

template<class Matrix , class CoordSystem , class U >
PositionVector3D< CoordSystem, U >	ROOT::Math::VectorUtil::Mult (const Matrix &m, const PositionVector3D< CoordSystem, U > &p)
	Multiplications of a generic matrices with a generic PositionVector Assume that the matrix implements the operator( i,j) and that it has at least 3 columns and 3 rows.

template<class Vector1 , class Vector2 >
double	ROOT::ROOT_MATH_ARCH::VectorUtil::Perp (const Vector1 &v, const Vector2 &u)
	Find the magnitude of the vector component of v perpendicular to the given direction of u.

template<class Vector1 , class Vector2 >
double	ROOT::Math::VectorUtil::Perp (const Vector1 &v, const Vector2 &u)
	Find the magnitude of the vector component of v perpendicular to the given direction of u.

template<class Vector1 , class Vector2 >
double	ROOT::ROOT_MATH_ARCH::VectorUtil::Perp2 (const Vector1 &v, const Vector2 &u)
	Find the magnitude square of the vector component of v perpendicular to the given direction of u.

template<class Vector1 , class Vector2 >
double	ROOT::Math::VectorUtil::Perp2 (const Vector1 &v, const Vector2 &u)
	Find the magnitude square of the vector component of v perpendicular to the given direction of u.

template<class Vector1 , class Vector2 >
Vector1	ROOT::ROOT_MATH_ARCH::VectorUtil::PerpVector (const Vector1 &v, const Vector2 &u)
	Find the vector component of v perpendicular to the given direction of u.

template<class Vector1 , class Vector2 >
Vector1	ROOT::Math::VectorUtil::PerpVector (const Vector1 &v, const Vector2 &u)
	Find the vector component of v perpendicular to the given direction of u.

double	ROOT::ROOT_MATH_ARCH::VectorUtil::Phi_0_2pi (double phi)
	Return a phi angle in the interval (0,2*PI].

double	ROOT::Math::VectorUtil::Phi_0_2pi (double phi)
	Return a phi angle in the interval (0,2*PI].

double	ROOT::ROOT_MATH_ARCH::VectorUtil::Phi_mpi_pi (double phi)
	Returns phi angle in the interval (-PI,PI].

double	ROOT::Math::VectorUtil::Phi_mpi_pi (double phi)
	Returns phi angle in the interval (-PI,PI].

template<class Vector1 , class Vector2 >
Vector1	ROOT::ROOT_MATH_ARCH::VectorUtil::ProjVector (const Vector1 &v, const Vector2 &u)
	Find the projection of v along the given direction u.

template<class Vector1 , class Vector2 >
Vector1	ROOT::Math::VectorUtil::ProjVector (const Vector1 &v, const Vector2 &u)
	Find the projection of v along the given direction u.

template<class Vector , class RotationMatrix >
Vector	ROOT::ROOT_MATH_ARCH::VectorUtil::Rotate (const Vector &v, const RotationMatrix &rot)
	rotation on a generic vector using a generic rotation class.

template<class Vector , class RotationMatrix >
Vector	ROOT::Math::VectorUtil::Rotate (const Vector &v, const RotationMatrix &rot)
	rotation on a generic vector using a generic rotation class.

template<class Vector >
Vector	ROOT::ROOT_MATH_ARCH::VectorUtil::Rotate (const Vector &v, double alpha, const Vector &axis)
	rotation along a custom axis for a generic vector by an Angle alpha (in rad) returning a new vector.

template<class Vector >
Vector	ROOT::Math::VectorUtil::Rotate (const Vector &v, double alpha, const Vector &axis)
	rotation along a custom axis for a generic vector by an Angle alpha (in rad) returning a new vector.

template<class Vector >
Vector	ROOT::ROOT_MATH_ARCH::VectorUtil::RotateX (const Vector &v, double alpha)
	rotation along X axis for a generic vector by an Angle alpha returning a new vector.

template<class Vector >
Vector	ROOT::Math::VectorUtil::RotateX (const Vector &v, double alpha)
	rotation along X axis for a generic vector by an Angle alpha returning a new vector.

template<class Vector >
Vector	ROOT::ROOT_MATH_ARCH::VectorUtil::RotateY (const Vector &v, double alpha)
	rotation along Y axis for a generic vector by an Angle alpha returning a new vector.

template<class Vector >
Vector	ROOT::Math::VectorUtil::RotateY (const Vector &v, double alpha)
	rotation along Y axis for a generic vector by an Angle alpha returning a new vector.

template<class Vector >
Vector	ROOT::ROOT_MATH_ARCH::VectorUtil::RotateZ (const Vector &v, double alpha)
	rotation along Z axis for a generic vector by an Angle alpha returning a new vector.

template<class Vector >
Vector	ROOT::Math::VectorUtil::RotateZ (const Vector &v, double alpha)
	rotation along Z axis for a generic vector by an Angle alpha returning a new vector.

Function Documentation

◆ Acoplanarity() [1/2]

template<class CoordSystem >

LorentzVector< CoordSystem >::Scalar ROOT::ROOT_MATH_ARCH::Acoplanarity	(	LorentzVector< CoordSystem > const &	pp,
		LorentzVector< CoordSystem > const &	pm )

pair (p+ p-) acoplanarity alpha = 1 - |phi+ - phi-|/pi.

Parameters

pp	p+, LorentzVector based on any coordinate system
pm	p-, LorentzVector based on any coordinate system

Returns: a scalar

See also: http://doi.org/10.1103/PhysRevLett.121.212301

Definition at line 797 of file LorentzVector.h.

◆ Acoplanarity() [2/2]

template<class CoordSystem >

LorentzVector< CoordSystem >::Scalar ROOT::Math::Acoplanarity	(	LorentzVector< CoordSystem > const &	pp,
		LorentzVector< CoordSystem > const &	pm )

pair (p+ p-) acoplanarity alpha = 1 - |phi+ - phi-|/pi.

Parameters

pp	p+, LorentzVector based on any coordinate system
pm	p-, LorentzVector based on any coordinate system

Returns: a scalar

See also: http://doi.org/10.1103/PhysRevLett.121.212301

Definition at line 746 of file LorentzVector.h.

◆ Angle() [1/2]

template<class Vector1 , class Vector2 >

double ROOT::ROOT_MATH_ARCH::VectorUtil::Angle	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find Angle between two vectors.

Use the CosTheta() function

Parameters

v1	Vector v1
v2	Vector v2

Returns: Angle between the two vectors
\[ \theta = \cos ^{-1} \frac { \vec{v1} \cdot \vec{v2} }{ | \vec{v1} | | \vec{v2} | } \]

Definition at line 171 of file VectorUtil.h.

◆ Angle() [2/2]

template<class Vector1 , class Vector2 >

double ROOT::Math::VectorUtil::Angle	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find Angle between two vectors.

Use the CosTheta() function

Parameters

v1	Vector v1
v2	Vector v2

Returns: Angle between the two vectors
\[ \theta = \cos ^{-1} \frac { \vec{v1} \cdot \vec{v2} }{ | \vec{v1} | | \vec{v2} | } \]

Definition at line 170 of file VectorUtil.h.

◆ AsymmetryScalar() [1/2]

template<class CoordSystem >

LorentzVector< CoordSystem >::Scalar ROOT::ROOT_MATH_ARCH::AsymmetryScalar	(	LorentzVector< CoordSystem > const &	pp,
		LorentzVector< CoordSystem > const &	pm )

pair (p+ p-) scalar asymmetry As = ||Pt+| - |Pt-|/||Pt+| + |Pt-||.

Measures the relative difference in transverse momentum of the pair, e.g. two photons, and would be ideally zero for two back-to-back photons.

Parameters

pp	p+, LorentzVector based on any coordinate system
pm	p-, LorentzVector based on any coordinate system

Returns: a scalar. Returns 0 if both transverse momenta are zero

See also: http://doi.org/10.1103/PhysRevLett.121.212301, https://doi.org/10.1103/PhysRevD.99.093013

Definition at line 847 of file LorentzVector.h.

◆ AsymmetryScalar() [2/2]

template<class CoordSystem >

LorentzVector< CoordSystem >::Scalar ROOT::Math::AsymmetryScalar	(	LorentzVector< CoordSystem > const &	pp,
		LorentzVector< CoordSystem > const &	pm )

pair (p+ p-) scalar asymmetry As = ||Pt+| - |Pt-|/||Pt+| + |Pt-||.

Measures the relative difference in transverse momentum of the pair, e.g. two photons, and would be ideally zero for two back-to-back photons.

Parameters

pp	p+, LorentzVector based on any coordinate system
pm	p-, LorentzVector based on any coordinate system

Returns: a scalar. Returns 0 if both transverse momenta are zero

See also: http://doi.org/10.1103/PhysRevLett.121.212301, https://doi.org/10.1103/PhysRevD.99.093013

Definition at line 795 of file LorentzVector.h.

◆ AsymmetryVectorial() [1/2]

template<class CoordSystem >

LorentzVector< CoordSystem >::Scalar ROOT::ROOT_MATH_ARCH::AsymmetryVectorial	(	LorentzVector< CoordSystem > const &	pp,
		LorentzVector< CoordSystem > const &	pm )

pair (p+ p-) vectorial asymmetry Av = |Pt+ - Pt-|/|Pt+ + Pt-|.

In an experimental setting, it reflects a convolution of the experimental resolutions of particle energy and azimuthal angle measurement.

Parameters

pp	p+, LorentzVector based on any coordinate system
pm	p-, LorentzVector based on any coordinate system

Returns: a scalar. Returns -1 if both momenta are exactly mirrored.

See also: http://doi.org/10.1103/PhysRevLett.121.212301, https://doi.org/10.1103/PhysRevD.99.093013

Definition at line 825 of file LorentzVector.h.

◆ AsymmetryVectorial() [2/2]

template<class CoordSystem >

LorentzVector< CoordSystem >::Scalar ROOT::Math::AsymmetryVectorial	(	LorentzVector< CoordSystem > const &	pp,
		LorentzVector< CoordSystem > const &	pm )

pair (p+ p-) vectorial asymmetry Av = |Pt+ - Pt-|/|Pt+ + Pt-|.

In an experimental setting, it reflects a convolution of the experimental resolutions of particle energy and azimuthal angle measurement.

Parameters

pp	p+, LorentzVector based on any coordinate system
pm	p-, LorentzVector based on any coordinate system

Returns: a scalar. Returns -1 if both momenta are exactly mirrored.

See also: http://doi.org/10.1103/PhysRevLett.121.212301, https://doi.org/10.1103/PhysRevD.99.093013

Definition at line 774 of file LorentzVector.h.

◆ boost() [1/2]

template<class LVector , class BoostVector >

LVector ROOT::ROOT_MATH_ARCH::VectorUtil::boost	(	const LVector &	v,
		const BoostVector &	b )

Boost a generic Lorentz Vector class using a generic 3D Vector class describing the boost The only requirement on the vector is that implements the X(), Y(), Z(), T() and SetXYZT methods.

The requirement on the boost vector is that needs to implement the X(), Y() , Z() retorning the vector elements describing the boost The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned

Definition at line 412 of file VectorUtil.h.

◆ boost() [2/2]

template<class LVector , class BoostVector >

LVector ROOT::Math::VectorUtil::boost	(	const LVector &	v,
		const BoostVector &	b )

Boost a generic Lorentz Vector class using a generic 3D Vector class describing the boost The only requirement on the vector is that implements the X(), Y(), Z(), T() and SetXYZT methods.

The requirement on the boost vector is that needs to implement the X(), Y() , Z() retorning the vector elements describing the boost The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned

Definition at line 408 of file VectorUtil.h.

◆ boostX() [1/2]

template<class LVector , class T >

LVector ROOT::ROOT_MATH_ARCH::VectorUtil::boostX	(	const LVector &	v,
		T	beta )

Boost a generic Lorentz Vector class along the X direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() and SetXYZT methods.

The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned

Definition at line 443 of file VectorUtil.h.

◆ boostX() [2/2]

template<class LVector , class T >

LVector ROOT::Math::VectorUtil::boostX	(	const LVector &	v,
		T	beta )

Boost a generic Lorentz Vector class along the X direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() and SetXYZT methods.

The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned

Definition at line 438 of file VectorUtil.h.

◆ boostY() [1/2]

template<class LVector >

LVector ROOT::ROOT_MATH_ARCH::VectorUtil::boostY	(	const LVector &	v,
		double	beta )

Boost a generic Lorentz Vector class along the Y direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() methods and be constructed from x,y,z,t values The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned.

Definition at line 467 of file VectorUtil.h.

◆ boostY() [2/2]

template<class LVector >

LVector ROOT::Math::VectorUtil::boostY	(	const LVector &	v,
		double	beta )

Boost a generic Lorentz Vector class along the Y direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() methods and be constructed from x,y,z,t values The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned.

Definition at line 460 of file VectorUtil.h.

◆ boostZ() [1/2]

template<class LVector >

LVector ROOT::ROOT_MATH_ARCH::VectorUtil::boostZ	(	const LVector &	v,
		double	beta )

Boost a generic Lorentz Vector class along the Z direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() methods and be constructed from x,y,z,t values The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned.

Definition at line 490 of file VectorUtil.h.

◆ boostZ() [2/2]

template<class LVector >

LVector ROOT::Math::VectorUtil::boostZ	(	const LVector &	v,
		double	beta )

Boost a generic Lorentz Vector class along the Z direction with a factor beta The only requirement on the vector is that implements the X(), Y(), Z(), T() methods and be constructed from x,y,z,t values The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned.

Definition at line 481 of file VectorUtil.h.

◆ CosTheta() [1/2]

template<class Vector1 , class Vector2 >

double ROOT::ROOT_MATH_ARCH::VectorUtil::CosTheta	(	const Vector1 &	v1,
		const Vector2 &	v2 )

Find CosTheta Angle between two generic 3D vectors pre-requisite: vectors implement the X(), Y() and Z()

Parameters

v1	Vector v1
v2	Vector v2

Returns: cosine of Angle between the two vectors
\[ \cos \theta = \frac { \vec{v1} \cdot \vec{v2} }{ | \vec{v1} | | \vec{v2} | } \]

Definition at line 143 of file VectorUtil.h.

◆ CosTheta() [2/2]

template<class Vector1 , class Vector2 >

double ROOT::Math::VectorUtil::CosTheta	(	const Vector1 &	v1,
		const Vector2 &	v2 )

Find CosTheta Angle between two generic 3D vectors pre-requisite: vectors implement the X(), Y() and Z()

Parameters

v1	Vector v1
v2	Vector v2

Returns: cosine of Angle between the two vectors
\[ \cos \theta = \frac { \vec{v1} \cdot \vec{v2} }{ | \vec{v1} | | \vec{v2} | } \]

Definition at line 143 of file VectorUtil.h.

◆ DeltaPhi() [1/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaPhi	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find aximutal Angle difference between two generic vectors ( v2.Phi() - v1.Phi() ) The only requirements on the Vector classes is that they implement the Phi() method.

Parameters

v1	Vector of any type implementing the Phi() operator
v2	Vector of any type implementing the Phi() operator

Returns: Phi difference
\[ \Delta \phi = \phi_2 - \phi_1 \]

Definition at line 61 of file VectorUtil.h.

◆ DeltaPhi() [2/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::Math::VectorUtil::DeltaPhi	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find aximutal Angle difference between two generic vectors ( v2.Phi() - v1.Phi() ) The only requirements on the Vector classes is that they implement the Phi() method.

Parameters

v1	Vector of any type implementing the Phi() operator
v2	Vector of any type implementing the Phi() operator

Returns: Phi difference
\[ \Delta \phi = \phi_2 - \phi_1 \]

Definition at line 62 of file VectorUtil.h.

◆ DeltaR() [1/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaR	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find difference in pseudorapidity (Eta) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Eta() method.

Parameters

v1	Vector 1
v2	Vector 2

Returns: Angle between the two vectors
\[ \Delta R = \sqrt{ ( \Delta \phi )^2 + ( \Delta \eta )^2 } \]

Definition at line 113 of file VectorUtil.h.

◆ DeltaR() [2/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::Math::VectorUtil::DeltaR	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find difference in pseudorapidity (Eta) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Eta() method.

Parameters

v1	Vector 1
v2	Vector 2

Returns: Angle between the two vectors
\[ \Delta R = \sqrt{ ( \Delta \phi )^2 + ( \Delta \eta )^2 } \]

Definition at line 113 of file VectorUtil.h.

◆ DeltaR2() [1/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaR2	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find square of the difference in pseudorapidity (Eta) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Eta() method.

Parameters

v1	Vector 1
v2	Vector 2

Returns: Angle between the two vectors
\[ \Delta R2 = ( \Delta \phi )^2 + ( \Delta \eta )^2 \]

Definition at line 81 of file VectorUtil.h.

◆ DeltaR2() [2/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::Math::VectorUtil::DeltaR2	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find square of the difference in pseudorapidity (Eta) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Eta() method.

Parameters

v1	Vector 1
v2	Vector 2

Returns: Angle between the two vectors
\[ \Delta R2 = ( \Delta \phi )^2 + ( \Delta \eta )^2 \]

Definition at line 83 of file VectorUtil.h.

◆ DeltaR2RapidityPhi() [1/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaR2RapidityPhi	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find square of the difference in true rapidity (y) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Rapidity() method.

Parameters

v1	Vector 1
v2	Vector 2

Returns: Angle between the two vectors
\[ \Delta R2 = ( \Delta \phi )^2 + ( \Delta \y )^2 \]

Definition at line 97 of file VectorUtil.h.

◆ DeltaR2RapidityPhi() [2/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::Math::VectorUtil::DeltaR2RapidityPhi	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find square of the difference in true rapidity (y) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Rapidity() method.

Parameters

v1	Vector 1
v2	Vector 2

Returns: Angle between the two vectors
\[ \Delta R2 = ( \Delta \phi )^2 + ( \Delta \y )^2 \]

Definition at line 98 of file VectorUtil.h.

◆ DeltaRapidityPhi() [1/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::ROOT_MATH_ARCH::VectorUtil::DeltaRapidityPhi	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find difference in Rapidity (y) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Rapidity() method.

Parameters

v1	Vector 1
v2	Vector 2

Returns: Angle between the two vectors
\[ \Delta R = \sqrt{ ( \Delta \phi )^2 + ( \Delta y )^2 } \]
,

Definition at line 127 of file VectorUtil.h.

◆ DeltaRapidityPhi() [2/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::Math::VectorUtil::DeltaRapidityPhi	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Find difference in Rapidity (y) and Phi between two generic vectors The only requirements on the Vector classes is that they implement the Phi() and Rapidity() method.

Parameters

v1	Vector 1
v2	Vector 2

Returns: Angle between the two vectors
\[ \Delta R = \sqrt{ ( \Delta \phi )^2 + ( \Delta y )^2 } \]
,

Definition at line 127 of file VectorUtil.h.

◆ InvariantMass() [1/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::ROOT_MATH_ARCH::VectorUtil::InvariantMass	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

return the invariant mass of two LorentzVector The only requirement on the LorentzVector is that they need to implement the X() , Y(), Z() and E() methods.

Parameters

v1	LorenzVector 1
v2	LorenzVector 2

Returns: invariant mass M
\[ M_{12} = \sqrt{ (\vec{v1} + \vec{v2} ) \cdot (\vec{v1} + \vec{v2} ) } \]

Definition at line 251 of file VectorUtil.h.

◆ InvariantMass() [2/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::Math::VectorUtil::InvariantMass	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

return the invariant mass of two LorentzVector The only requirement on the LorentzVector is that they need to implement the X() , Y(), Z() and E() methods.

Parameters

v1	LorenzVector 1
v2	LorenzVector 2

Returns: invariant mass M
\[ M_{12} = \sqrt{ (\vec{v1} + \vec{v2} ) \cdot (\vec{v1} + \vec{v2} ) } \]

Definition at line 249 of file VectorUtil.h.

◆ InvariantMass2() [1/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::ROOT_MATH_ARCH::VectorUtil::InvariantMass2	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Returns the square of what InvariantMass(const Vector1&, const Vector2&) would return.

This is mostly useful for speed optimisations, because the expensive sqrt operation is skipped.

Definition at line 268 of file VectorUtil.h.

◆ InvariantMass2() [2/2]

template<class Vector1 , class Vector2 >

Vector1::Scalar ROOT::Math::VectorUtil::InvariantMass2	(	const Vector1 &	v1,
		const Vector2 &	v2 )

inline

Returns the square of what InvariantMass(const Vector1&, const Vector2&) would return.

This is mostly useful for speed optimisations, because the expensive sqrt operation is skipped.

Definition at line 266 of file VectorUtil.h.

◆ Mult() [1/6]

template<class Matrix , class CoordSystem , class U >

DisplacementVector3D< CoordSystem, U > ROOT::ROOT_MATH_ARCH::VectorUtil::Mult	(	const Matrix &	m,
		const DisplacementVector3D< CoordSystem, U > &	v )

inline

Multiplications of a generic matrices with a DisplacementVector3D of any coordinate system.

Assume that the matrix implements the operator( i,j) and that it has at least 3 columns and 3 rows. There is no check on the matrix size !!

Definition at line 518 of file VectorUtil.h.

◆ Mult() [2/6]

template<class Matrix , class CoordSystem , class U >

DisplacementVector3D< CoordSystem, U > ROOT::Math::VectorUtil::Mult	(	const Matrix &	m,
		const DisplacementVector3D< CoordSystem, U > &	v )

inline

Multiplications of a generic matrices with a DisplacementVector3D of any coordinate system.

Assume that the matrix implements the operator( i,j) and that it has at least 3 columns and 3 rows. There is no check on the matrix size !!

Definition at line 505 of file VectorUtil.h.

◆ Mult() [3/6]

template<class CoordSystem , class Matrix >

LorentzVector< CoordSystem > ROOT::ROOT_MATH_ARCH::VectorUtil::Mult	(	const Matrix &	m,
		const LorentzVector< CoordSystem > &	v )

inline

Multiplications of a generic matrices with a LorentzVector described in any coordinate system.

Assume that the matrix implements the operator( i,j) and that it has at least 4 columns and 4 rows. There is no check on the matrix size !!

Definition at line 548 of file VectorUtil.h.

◆ Mult() [4/6]

template<class CoordSystem , class Matrix >

LorentzVector< CoordSystem > ROOT::Math::VectorUtil::Mult	(	const Matrix &	m,
		const LorentzVector< CoordSystem > &	v )

inline

Multiplications of a generic matrices with a LorentzVector described in any coordinate system.

Assume that the matrix implements the operator( i,j) and that it has at least 4 columns and 4 rows. There is no check on the matrix size !!

Definition at line 537 of file VectorUtil.h.

◆ Mult() [5/6]

template<class Matrix , class CoordSystem , class U >

PositionVector3D< CoordSystem, U > ROOT::ROOT_MATH_ARCH::VectorUtil::Mult	(	const Matrix &	m,
		const PositionVector3D< CoordSystem, U > &	p )

inline

Multiplications of a generic matrices with a generic PositionVector Assume that the matrix implements the operator( i,j) and that it has at least 3 columns and 3 rows.

There is no check on the matrix size !!

Definition at line 532 of file VectorUtil.h.

◆ Mult() [6/6]

template<class Matrix , class CoordSystem , class U >

PositionVector3D< CoordSystem, U > ROOT::Math::VectorUtil::Mult	(	const Matrix &	m,
		const PositionVector3D< CoordSystem, U > &	p )

inline

Multiplications of a generic matrices with a generic PositionVector Assume that the matrix implements the operator( i,j) and that it has at least 3 columns and 3 rows.

There is no check on the matrix size !!

Definition at line 520 of file VectorUtil.h.

◆ Perp() [1/2]

template<class Vector1 , class Vector2 >

double ROOT::ROOT_MATH_ARCH::VectorUtil::Perp	(	const Vector1 &	v,
		const Vector2 &	u )

inline

Find the magnitude of the vector component of v perpendicular to the given direction of u.

Parameters

v	Vector v for which the perpendicular component is to be found
u	Vector specifying the direction

Returns: value of the component of v which is perpendicular to u
\[ perp = | \vec{v} - \frac{ \vec{v} \cdot \vec{u} }{|\vec{u}|}\vec{u} | \]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()

Definition at line 234 of file VectorUtil.h.

◆ Perp() [2/2]

template<class Vector1 , class Vector2 >

double ROOT::Math::VectorUtil::Perp	(	const Vector1 &	v,
		const Vector2 &	u )

inline

Find the magnitude of the vector component of v perpendicular to the given direction of u.

Parameters

v	Vector v for which the perpendicular component is to be found
u	Vector specifying the direction

Returns: value of the component of v which is perpendicular to u
\[ perp = | \vec{v} - \frac{ \vec{v} \cdot \vec{u} }{|\vec{u}|}\vec{u} | \]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()

Definition at line 229 of file VectorUtil.h.

◆ Perp2() [1/2]

template<class Vector1 , class Vector2 >

double ROOT::ROOT_MATH_ARCH::VectorUtil::Perp2	(	const Vector1 &	v,
		const Vector2 &	u )

inline

Find the magnitude square of the vector component of v perpendicular to the given direction of u.

Parameters

v	Vector v for which the perpendicular component is to be found
u	Vector specifying the direction

Returns: square value of the component of v which is perpendicular to u
\[ perp = | \vec{v} - \frac{ \vec{v} \cdot \vec{u} }{|\vec{u}|}\vec{u} |^2 \]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()

Definition at line 217 of file VectorUtil.h.

◆ Perp2() [2/2]

template<class Vector1 , class Vector2 >

double ROOT::Math::VectorUtil::Perp2	(	const Vector1 &	v,
		const Vector2 &	u )

inline

Find the magnitude square of the vector component of v perpendicular to the given direction of u.

Parameters

v	Vector v for which the perpendicular component is to be found
u	Vector specifying the direction

Returns: square value of the component of v which is perpendicular to u
\[ perp = | \vec{v} - \frac{ \vec{v} \cdot \vec{u} }{|\vec{u}|}\vec{u} |^2 \]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()

Definition at line 213 of file VectorUtil.h.

◆ PerpVector() [1/2]

template<class Vector1 , class Vector2 >

Vector1 ROOT::ROOT_MATH_ARCH::VectorUtil::PerpVector	(	const Vector1 &	v,
		const Vector2 &	u )

inline

Find the vector component of v perpendicular to the given direction of u.

Parameters

v	Vector v for which the perpendicular component is to be found
u	Vector specifying the direction

Returns: Vector component of v which is perpendicular to u
\[ \vec{perp} = \vec{v} - \frac{ \vec{v} \cdot \vec{u} }{|\vec{u}|}\vec{u} \]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()

Definition at line 203 of file VectorUtil.h.

◆ PerpVector() [2/2]

template<class Vector1 , class Vector2 >

Vector1 ROOT::Math::VectorUtil::PerpVector	(	const Vector1 &	v,
		const Vector2 &	u )

inline

Find the vector component of v perpendicular to the given direction of u.

Parameters

v	Vector v for which the perpendicular component is to be found
u	Vector specifying the direction

Returns: Vector component of v which is perpendicular to u
\[ \vec{perp} = \vec{v} - \frac{ \vec{v} \cdot \vec{u} }{|\vec{u}|}\vec{u} \]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()

Definition at line 200 of file VectorUtil.h.

◆ Phi_0_2pi() [1/2]

double ROOT::ROOT_MATH_ARCH::VectorUtil::Phi_0_2pi ( double phi )

Return a phi angle in the interval (0,2*PI].

Definition at line 25 of file VectorUtil.cxx.

◆ Phi_0_2pi() [2/2]

double ROOT::Math::VectorUtil::Phi_0_2pi ( double phi )

Return a phi angle in the interval (0,2*PI].

Definition at line 23 of file VectorUtil.cxx.

◆ Phi_mpi_pi() [1/2]

double ROOT::ROOT_MATH_ARCH::VectorUtil::Phi_mpi_pi ( double phi )

Returns phi angle in the interval (-PI,PI].

Definition at line 41 of file VectorUtil.cxx.

◆ Phi_mpi_pi() [2/2]

double ROOT::Math::VectorUtil::Phi_mpi_pi ( double phi )

Returns phi angle in the interval (-PI,PI].

Definition at line 38 of file VectorUtil.cxx.

◆ ProjVector() [1/2]

template<class Vector1 , class Vector2 >

Vector1 ROOT::ROOT_MATH_ARCH::VectorUtil::ProjVector	(	const Vector1 &	v,
		const Vector2 &	u )

Find the projection of v along the given direction u.

Parameters

v	Vector v for which the propjection is to be found
u	Vector specifying the direction

Returns: Vector projection (same type of v)
\[ \vec{proj} = \frac{ \vec{v} \cdot \vec{u} }{|\vec{u}|}\vec{u} \]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()

Definition at line 185 of file VectorUtil.h.

◆ ProjVector() [2/2]

template<class Vector1 , class Vector2 >

Vector1 ROOT::Math::VectorUtil::ProjVector	(	const Vector1 &	v,
		const Vector2 &	u )

Find the projection of v along the given direction u.

Parameters

v	Vector v for which the propjection is to be found
u	Vector specifying the direction

Returns: Vector projection (same type of v)
\[ \vec{proj} = \frac{ \vec{v} \cdot \vec{u} }{|\vec{u}|}\vec{u} \]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()

Definition at line 184 of file VectorUtil.h.

◆ Rotate() [1/4]

template<class Vector , class RotationMatrix >

Vector ROOT::ROOT_MATH_ARCH::VectorUtil::Rotate	(	const Vector &	v,
		const RotationMatrix &	rot )

rotation on a generic vector using a generic rotation class.

The only requirement on the vector is that implements the X(), Y(), Z() and SetXYZ methods. The requirement on the rotation matrix is that need to implement the (i,j) operator returning the matrix element with R(0,0) = xx element

Definition at line 390 of file VectorUtil.h.

◆ Rotate() [2/4]

template<class Vector , class RotationMatrix >

Vector ROOT::Math::VectorUtil::Rotate	(	const Vector &	v,
		const RotationMatrix &	rot )

rotation on a generic vector using a generic rotation class.

The only requirement on the vector is that implements the X(), Y(), Z() and SetXYZ methods. The requirement on the rotation matrix is that need to implement the (i,j) operator returning the matrix element with R(0,0) = xx element

Definition at line 387 of file VectorUtil.h.

◆ Rotate() [3/4]

template<class Vector >

Vector ROOT::ROOT_MATH_ARCH::VectorUtil::Rotate	(	const Vector &	v,
		double	alpha,
		const Vector &	axis )

rotation along a custom axis for a generic vector by an Angle alpha (in rad) returning a new vector.