Quick Links: ROOT Homepage Class Index Class Hierarchy

Sections: class description function members data members class charts

class HPoint<float>

 HPoint -- a simple 3D point

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

HPoint<Float_t>, HPointF::TP

Function Members (Methods)

public:

	HPoint<float>()
	HPoint<float>(const Float_t* p)
	HPoint<float>(const Double_t* p)
	HPoint<float>(const HPoint<float>&)
	HPoint<float>(float _x, float _y, float _z)
	~HPoint<float>()
HPoint<float>&	Add(float _x, float _y, float _z)
const float*	Arr() const
float*	Arr()
float	CosTheta() const
HPoint<float>	Cross(const HPoint<float>& b) const
HPoint<float>&	Cross(const HPoint<float>& a, const HPoint<float>& b)
float	Distance(const HPoint<float>& b) const
float	Dot(const HPoint<float>& v) const
float	Dot(const Float_t* v) const
float	Dot(const Double_t* v) const
float	Eta() const
float	Mag() const
float	Mag2() const
float	Magnitude() const
HPoint<float>&	Neg()
float	Normalize(float length = 1)
const float*	operator const float*() const
float*	operator float*()
HPoint<float>&	operator*=(float f)
HPoint<float>&	operator+=(const HPoint<float>& a)
HPoint<float>&	operator+=(const Float_t* v)
HPoint<float>&	operator+=(const Double_t* v)
HPoint<float>&	operator-=(const HPoint<float>& a)
HPoint<float>&	operator-=(const Float_t* v)
HPoint<float>&	operator-=(const Double_t* v)
HPoint<float>&	operator/=(float d)
HPoint<float>&	operator=(const HPoint<float>&)
float	operator[](Int_t idx) const
float&	operator[](Int_t idx)
HPoint<float>	Orthogonal() const
void	OrthoNormBase(HPoint<float>& a, HPoint<float>& b) const
float	Perp() const
float	Perp2() const
float	Phi() const
void	Print() const
void	Set(const Float_t* p)
void	Set(const Double_t* p)
void	Set(float _x, float _y, float _z)
float	SquareDistance(const HPoint<float>& b) const
float	SquareMagnitude() const
float	Theta() const
void	Zero()

Data Members

public:

float	x
float	y
float	z

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

TT HPoint<TT> SquareDistance(const HPoint<float>& b) const

TT HPoint<TT> Distance(const HPoint<float>& b) const

HPoint<TT> HPoint<TT> Cross(const HPoint<float>& b) const

HPoint<TT>& HPoint<TT> Cross(const HPoint<float>& a, const HPoint<float>& b)

const TT* Arr() const

{ return &x; }

TT* Arr()

{ return &x; }

void Set(float _x, float _y, float _z)

{ x = _x; y = _y; z = _z; }

void Set(const Float_t* p)

{ x = p[0]; y = p[1]; z = p[2]; }

void Set(const Double_t* p)

{ x = p[0]; y = p[1]; z = p[2]; }

void Zero()

{ x = y = z = 0; }

HPoint& Neg()

{ x = -x; y = -y; z = -z; return *this; }

HPoint& Add(float _x, float _y, float _z)

{ x += _x; y += _y; z += _z; return *this; }

HPoint& operator+=(const HPoint& a)

{ x += a.x; y += a.y; z += a.z; return *this; }

HPoint& operator+=(const Float_t* v)

{ x += v[0]; y += v[1]; z += v[2]; return *this; }

HPoint& operator+=(const Double_t* v)

{ x += v[0]; y += v[1]; z += v[2]; return *this; }

HPoint& operator-=(const HPoint& a)

{ x -= a.x; y -= a.y; z -= a.z; return *this; }

HPoint& operator-=(const Float_t* v)

{ x -= v[0]; y -= v[1]; z -= v[2]; return *this; }

HPoint& operator-=(const Double_t* v)

{ x -= v[0]; y -= v[1]; z -= v[2]; return *this; }

HPoint& operator*=(float f)

{ x *= f; y *= f; z *= f; return *this; }

HPoint& operator/=(float d)

{ return operator*=(1/d); }

TT Dot(const HPoint& v)

{ return x*v.x + y*v.y + z*v.z; }

TT Dot(const Float_t* v) const

{ return x*v[0] + y*v[1] + z*v[2]; }

TT Dot(const Double_t* v) const

{ return x*v[0] + y*v[1] + z*v[2]; }

TT SquareMagnitude() const

{ return x*x + y*y + z*z; }

TT Magnitude() const

{ return TMath::Sqrt(SquareMagnitude()); }

TT Mag2() const

{ return x*x + y*y + z*z; }

TT Mag() const

{ return TMath::Sqrt(SquareMagnitude()); }

TT Perp2() const

{ return x*x + y*y; }

TT Perp() const

{ return TMath::Sqrt(Perp2()); }

TT Phi() const

{ return TMath::ATan2(y, x); }

TT Theta() const

{ return TMath::ATan2(Perp(), z); }

TT CosTheta() const

{ TT m = Mag(); return m == 0 ? 1 : z / m; }

TT Eta() const

TT Normalize(float length = 1)

HPoint Orthogonal() const

void OrthoNormBase(HPoint<float>& a, HPoint<float>& b) const

void Print() const

TT operator[](Int_t idx) const

{ return M[i]; }

TT& operator[](Int_t idx)

{ return M[i]; }