VERTEX::Track Class Reference

#include <VtTrack.hh>

Inheritance diagram for VERTEX::Track:

Collaboration diagram for VERTEX::Track:

Public Member Functions
— Constructors —
	Track ()
	Track (const Track *const track)
	Track (const Track &rhs)
	Track (const MATRIX::VtVector &v, const MATRIX::CMatrix &c)
virtual	~Track ()
void	set (double x, double y, double z, double tx, double ty, double p, const MATRIX::CMatrix &c)
Track &	operator= (const Track &rhs)
— TrackIf access methods —
float	x () const
	x at z=0 (in Vt: p(3,..)) More...
float	y () const
	y at z=0 (in Vt: p(4,..)) More...
float	x (float z) const
	Track $x$ position at $z$. More...
float	y (float z) const
	Track $y$ position at $z$. More...
float	z () const
	z = 0 in Vt More...
float	tx () const
	slope (in Vt: p(1,..)) More...
float	ty () const
	slope (in Vt: p(2,..)) More...
float	p () const
	momentum (in Vt: p(5,..)) More...
float	pt () const
	transv. momentum $\sqrt{p_x^2 + p_y^2}$ More...
float	pz () const
	$p \cdot e_z$ More...
float	chi2 () const
	dummy function: always return 0 More...
unsigned short int	ndf () const
	dummy function: always return 0 More...
float	phi () const
	azimuthal angle $\phi$ More...
float	theta () const
	polar angle $\theta = \cos^{-1}(e_z)$ More...
float	eta () const
	rapidity $-\log\tan(\theta/2.)$ More...
int	charge () const
	charge More...
float	energy (double rm=0.) const
	Energy with given rest-mass (in GeV) $E = \sqrt{p^2 + m^2}$. More...
float	xf (double rm=0.) const
	Feynman Variable $x_F = \frac{E+p_z}{(E+p_z)_{max}}$. More...
float	rap (double rm=0.) const
	Rapidity $y = \frac{1}{2}\ln(\frac{E+p_z}{E-p_z})$. More...
MATRIX::VtVector	evec () const
	$\vec{v} = (e_x,e_y,e_z)$ unit vector along refitted track More...
MATRIX::VtVector	tvec () const
	$\vec{v} = (t_x,t_y,1.)$ refitted slope vector More...
MATRIX::VtVector	pvec () const
	$\vec{v} = (p_x,p_y,p_z)$ refitted mom. vector More...
float	cov_x (double dz=0.) const
	get $\sigma_x^2|_{z+dz}$ More...
float	cov_y (double dz=0.) const
	get $\sigma_y^2|_{z+dz}$ More...
float	cov_tx () const
	get $\sigma_{t_x}^2$ More...
float	cov_ty () const
	get $\sigma_{t_y}^2$ More...
float	cov_p () const
	get $\sigma_p^2$ More...
bool	isValid () const
	dummy function: always return true More...
void	valid ()
	dummy function: do nothing More...
void	invalid ()
	dummy function: do nothing More...
bool	propagate (const double zz)
	propagate track to $z$ More...
— Other access methods —
double	px () const
	$p \cdot e_x$ More...
double	py () const
	$p \cdot e_y$ More...
double	ex () const
	$t_x \cdot e_z$ More...
double	ey () const
	$t_y \cdot e_z$ More...
double	ez () const
	$1/\sqrt{1+t_x^2+t_y^2}$ More...
double	xerr (double dz=0) const
	$\sqrt{\sigma_x^2(z+dz)}$ More...
double	yerr (double dz=0) const
	$\sqrt{\sigma_y^2(z+dz)}$ More...
double	txerr () const
	$\sqrt{\sigma^2_{tx}}$ More...
double	tyerr () const
	$\sqrt{\sigma^2_{ty}}$ More...
double	perr () const
	$\sqrt{\sigma^2_p}$ More...
const MATRIX::CMatrix &	V () const
	covariance matrix More...
const MATRIX::CMatrix &	G () const
	inverse $5\times5$ covariance matrix More...
const MATRIX::CMatrix &	GM () const
	inverse $4\times4$ covariance matrix, without momentum More...
— Expert functions —
std::ostream &	print (std::ostream &os) const
	called by cout More...
double	rm () const
	rest-mass More...
void	rm (const double mass)
	set rest-mass (needed for mass constrained fits) More...
double	rmCC () const
	conjugated rest-mass More...
void	rmCC (const double mass)
	set conjugated rest-mass More...
void	delete_mom ()
Public Member Functions inherited from VERTEX::RelationList
	RelationList ()
virtual	~RelationList ()
virtual void	clear ()
	clear all relations More...
void	push__back (Relation *rel)
	add a relation More...
Relation *	back () const
	return last relation More...
unsigned int	size () const
	return no of relations More...
virtual const iterator	erase (const iterator &pos)
	Erase an element. More...
iterator	begin ()
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
reverse_iterator	rbegin ()
reverse_iterator	rend ()
const_reverse_iterator	rbegin () const
const_reverse_iterator	rend () const
Relation *const	operator[] (unsigned int i) const
	direct access More...
void	print (std::ostream &os) const
void	unbook (Relation *const rel)
	get rid of relation pointer More...
virtual void	remove (Relation *const rel)
	remove a relation More...
const RelationList &	operator= (const RelationList &rhs)
bool	operator== (const RelationList &rhs) const

— Operators —
short int	t_Q
double	t_rm
double	t_rmCC
MATRIX::VtVector	t_p
MATRIX::CMatrix	t_V
MATRIX::CMatrix	t_G
MATRIX::CMatrix	t_GM
	ClassDef (Track, 1)

Additional Inherited Members
Public Types inherited from VERTEX::RelationList
typedef ConstRelationIterator	const_iterator
typedef ConstReverseRelationIterator	const_reverse_iterator
typedef RelationIterator	iterator
typedef ReverseRelationIterator	reverse_iterator

Detailed Description

Track representation class

Constructor & Destructor Documentation

Track() [1/4]

Track::Track

(

)

              :
    t_Q      (0),
    t_rm     (0.),
    t_rmCC   (0.),
    t_p      (VtVector(6))
  {}

Track() [2/4]

Track::Track

(

const Track *const

track

)

                                      :
    t_Q      (track->t_Q),
    t_rm     (track->t_rm),
    t_rmCC   (track->t_rmCC),
    t_p      (track->t_p),
    t_V      (track->t_V)
  {
    propagate(0.);           // propagate track to z=0.
    t_G = t_V.dsinv();
    t_GM.copy(t_V.dsinv(4)); // inverse without momentum
  }

Track() [3/4]

Track::Track

(

const Track &

rhs

)

                              :
    t_Q      (rhs.t_Q),
    t_rm     (rhs.t_rm),
    t_rmCC   (rhs.t_rmCC),
    t_p      (rhs.t_p),
    t_V      (rhs.t_V)
  {
    propagate(0.);           // propagate track to z=0.
    t_G = t_V.dsinv();
    t_GM.copy(t_V.dsinv(4)); // inverse without momentum
  }

Track() [4/4]

VERTEX::Track::Track	(	const MATRIX::VtVector &	v,
		const MATRIX::CMatrix &	c
	)

~Track()

Track::~Track ( )

virtual

{}

Member Function Documentation

charge()

int Track::charge

(

)

const

charge

{ return t_Q; }

chi2()

float Track::chi2

(

)

const

dummy function: always return 0

{ return 0; }

ClassDef()

VERTEX::Track::ClassDef ( Track  , 1    )

protected

cov_p()

float Track::cov_p

(

)

const

get $\sigma_p^2$

{ return t_V.p(); }

cov_tx()

float Track::cov_tx

(

)

const

get $\sigma_{t_x}^2$

{ return t_V(2,2); }

cov_ty()

float Track::cov_ty

(

)

const

get $\sigma_{t_y}^2$

{ return t_V(3,3); }

cov_x()

float Track::cov_x

(

double

dz = 0.

)

const

get $\sigma_x^2|_{z+dz}$

                                    {
    return t_V.x_prop(dz);
  }

cov_y()

float Track::cov_y

(

double

dz = 0.

)

const

get $\sigma_y^2|_{z+dz}$

                                    {
    return t_V.y_prop(dz);
  }

delete_mom()

void Track::delete_mom

(

)

                         {
    t_V.set_x_p(0.);
    t_V.set_y_p(0.);
    t_V.set_tx_p(0.);
    t_V.set_ty_p(0.);
    t_V.set_p(1e5);
    t_G = t_V;
    if(t_G.VtDsinv()==false)
      cout << " error inverting matrix!!" << endl;
    
  }

energy()

float Track::energy

(

double

rm = 0.

)

const

Energy with given rest-mass (in GeV) $E = \sqrt{p^2 + m^2}$.

{ return sqrt(sqr(t_p[5]) + sqr(rm)); }

eta()

float Track::eta

(

)

const

rapidity $-\log\tan(\theta/2.)$

{ return -log(tan(theta()/2.)); }

evec()

MATRIX::VtVector VERTEX::Track::evec ( ) const

inline

$\vec{v} = (e_x,e_y,e_z)$ unit vector along refitted track

{ return MATRIX::VtVector(ex(),ey(),ez()); }

ex()

double VERTEX::Track::ex

(

)

const

$t_x \cdot e_z$

ey()

double VERTEX::Track::ey

(

)

const

$t_y \cdot e_z$

ez()

double VERTEX::Track::ez

(

)

const

$1/\sqrt{1+t_x^2+t_y^2}$

G()

const MATRIX::CMatrix & Track::G

(

)

const

inverse $5\times5$ covariance matrix

{ return t_G; }

GM()

const MATRIX::CMatrix & Track::GM

(

)

const

inverse $4\times4$ covariance matrix, without momentum

{ return t_GM; }

invalid()

void Track::invalid

(

)

dummy function: do nothing

{ return; }

isValid()

bool Track::isValid

(

)

const

dummy function: always return true

{ return true; }

ndf()

unsigned short int Track::ndf

(

)

const

dummy function: always return 0

{ return 0; }

operator=()

Track & Track::operator=

(

const Track &

rhs

)

                                          {
    if(this == &rhs) { return *this; }
 
    RelationList::operator=(rhs);
 
    t_Q       = rhs.t_Q;
    t_rm      = rhs.t_rm;
    t_rmCC    = rhs.t_rmCC;
 
    t_p       = rhs.t_p;
    t_V       = rhs.t_V;
    t_G       = rhs.t_G;
    t_GM      = rhs.t_GM;
 
    return *this;
  }

p()

float Track::p

(

)

const

momentum (in Vt: p(5,..))

{ return t_p[5]; }

perr()

double VERTEX::Track::perr

(

)

const

$\sqrt{\sigma^2_p}$

phi()

float Track::phi

(

)

const

azimuthal angle $\phi$

{ return (180. + atan2(t_p[3],t_p[4])*57.29577957); }

print()

std::ostream & Track::print

(

std::ostream &

os

)

const

called by cout

                                                 {
 
    return os  << " x: "  << x()
           << " y: "  << y()
           << " z: "  << z()
           << " tx: " << tx()
           << " ty: " << ty()
           << " p: "  << p() 
           << endl
           << " Cov Matrix: " << V()
           << " inverse: " << G()
           << " inverse without momentum: " << GM();
  }

propagate()

bool Track::propagate

(

const double

zz

)

propagate track to $z$

                                       {
    if( zz == t_p[2] ) return true;
 
    const double dz = zz - t_p[2];
    t_p[0] += dz * t_p[3];
    t_p[1] += dz * t_p[4];
    t_p[2]  = zz;
    t_V.propagate(dz); // propagate Track covariance matrix
    return true;
  }

pt()

float Track::pt

(

)

const

transv. momentum $\sqrt{p_x^2 + p_y^2}$

{ return sqrt(sqr(px()) + sqr(py())); }

pvec()

MATRIX::VtVector VERTEX::Track::pvec ( ) const

inline

$\vec{v} = (p_x,p_y,p_z)$ refitted mom. vector

{ return MATRIX::VtVector(px(),py(),pz()); }

px()

double VERTEX::Track::px

(

)

const

$p \cdot e_x$

py()

double VERTEX::Track::py

(

)

const

$p \cdot e_y$

pz()

float Track::pz

(

)

const

$p \cdot e_z$

{ return t_p[5] * ez(); }

rap()

float Track::rap

(

double

rm = 0.

)

const

Rapidity $y = \frac{1}{2}\ln(\frac{E+p_z}{E-p_z})$.

{ return 0.5*log((energy(mass)+pz())/(energy(mass)-pz())); }

rm() [1/2]

double VERTEX::Track::rm

(

)

const

rest-mass

rm() [2/2]

void VERTEX::Track::rm

(

const double

mass

)

set rest-mass (needed for mass constrained fits)

rmCC() [1/2]

double VERTEX::Track::rmCC

(

)

const

conjugated rest-mass

rmCC() [2/2]

void VERTEX::Track::rmCC

(

const double

mass

)

set conjugated rest-mass

set()

void Track::set	(	double	x,
		double	y,
		double	z,
		double	tx,
		double	ty,
		double	p,
		const MATRIX::CMatrix &	c
	)

                                  {
    t_p[0] = x;
    t_p[1] = y;
    t_p[2] = z;
    t_p[3] = tx;
    t_p[4] = ty;
    t_p[5] = p;
    t_V.copy(c);
    propagate(0.);           // propagate track to z=0.
    t_G = t_V.dsinv();
    t_GM.copy(t_V.dsinv(4)); // inverse without momentum
  }

theta()

float Track::theta

(

)

const

polar angle $\theta = \cos^{-1}(e_z)$

{ return acos(ez()); }

tvec()

MATRIX::VtVector VERTEX::Track::tvec ( ) const

inline

$\vec{v} = (t_x,t_y,1.)$ refitted slope vector

{ return MATRIX::VtVector(tx(),ty(),1.); }

tx()

float Track::tx

(

)

const

slope (in Vt: p(1,..))

{ return t_p[3]; }

txerr()

double VERTEX::Track::txerr

(

)

const

$\sqrt{\sigma^2_{tx}}$

ty()

float Track::ty

(

)

const

slope (in Vt: p(2,..))

{ return t_p[4]; }

tyerr()

double VERTEX::Track::tyerr

(

)

const

$\sqrt{\sigma^2_{ty}}$

V()

const MATRIX::CMatrix & Track::V

(

)

const

covariance matrix

{ return t_V; }

valid()

void Track::valid

(

)

dummy function: do nothing

{ return; }

x() [1/2]

float Track::x

(

)

const

x at z=0 (in Vt: p(3,..))

{ return t_p[0]; }

x() [2/2]

float Track::x

(

float

z

)

const

Track $x$ position at $z$.

{ return t_p[0] + t_p[3] * (z-t_p[2]); }

xerr()

double VERTEX::Track::xerr

(

double

dz = 0

)

const

$\sqrt{\sigma_x^2(z+dz)}$

xf()

float Track::xf

(

double

rm = 0.

)

const

Feynman Variable $x_F = \frac{E+p_z}{(E+p_z)_{max}}$.

{ return (pz() - energy(mass)*0.99898)/0.93827; }

y() [1/2]

float Track::y

(

)

const

y at z=0 (in Vt: p(4,..))

{ return t_p[1]; }

y() [2/2]

float Track::y

(

float

z

)

const

Track $y$ position at $z$.

{ return t_p[1] + t_p[4] * (z-t_p[2]); }

yerr()

double VERTEX::Track::yerr

(

double

dz = 0

)

const

$\sqrt{\sigma_y^2(z+dz)}$

z()

float Track::z

(

)

const

z = 0 in Vt

{ return t_p[2]; }

Member Data Documentation

t_G

MATRIX::CMatrix VERTEX::Track::t_G

protected

t_GM

MATRIX::CMatrix VERTEX::Track::t_GM

protected

t_p

MATRIX::VtVector VERTEX::Track::t_p

protected

t_Q

short int VERTEX::Track::t_Q

private

t_rm

double VERTEX::Track::t_rm

private

t_rmCC

double VERTEX::Track::t_rmCC

private

t_V

MATRIX::CMatrix VERTEX::Track::t_V

protected

---

The documentation for this class was generated from the following files:

• src/libVt++/vt++/include/VtTrack.hh
• src/libVt++/vt++/VtTrack.C