VERTEX Namespace Reference

Namespaces
namespace	ROOTDict

Classes
class	ConstRelationIterator
class	ConstReverseRelationIterator
class	Kalman
class	MassC
class	Relation
class	RelationIterator
class	RelationList
class	ReverseRelationIterator
class	Track
class	Vertex
class	VtIni

Typedefs
typedef ConstRelationIterator	const_iterator
typedef ConstReverseRelationIterator	const_reverse_iterator
typedef RelationIterator	iterator
typedef std::list< MassC * >::const_iterator	MassC_cit
typedef std::list< MassC * >::iterator	MassC_it
typedef std::list< MassC * >	MassC_v
typedef std::vector< Relation * >::const_iterator	Rel_cit
typedef std::vector< Relation * >::iterator	Rel_it
typedef std::vector< Relation * >	Rel_v
typedef std::list< Relation * >::const_iterator	Relation_cit
typedef std::list< Relation * >::iterator	Relation_it
typedef std::list< Relation * >::const_reverse_iterator	Relation_rcit
typedef std::list< Relation * >::reverse_iterator	Relation_rit
typedef std::list< Relation * >	Relation_v
typedef ReverseRelationIterator	reverse_iterator
typedef std::vector< Track * >::const_iterator	Track_cit
typedef std::vector< Track * >::iterator	Track_it
typedef std::vector< Track * >	Track_v
typedef std::vector< double >	Vector_d

Functions
bool	createRelation (Track &t, Vertex &v)
std::ostream &	operator<< (std::ostream &os, const Kalman &k)
std::ostream &	operator<< (std::ostream &os, const Relation &r)
std::ostream &	operator<< (std::ostream &os, const Track &t)
std::ostream &	operator<< (std::ostream &os, const VtIni &t)
std::ostream &	operator<< (std::ostream &s, const MassC &a)
std::ostream &	operator<< (std::ostream &s, const RelationList &a)
std::ostream &	operator<< (std::ostream &s, const Vertex &a)
— Distance functions —
double	distanceChi2 (Track &t1, Track &t2)
	$\chi^2$ distance track - track, $ndf = 1$ More...
double	distance (const Track &t, const Vertex &v)
	spatial distance track - vertex More...
double	distance (const Vertex &v, const Track &t)
double	SGNdistance (const Track &t, const Vertex &v)
	signed spatial distance track - vertex More...
double	SGNdistance (const Vertex &v, const Track &t)
double	SGNdistance (const Track &t, double xv, double yv, double zv)
	signed spatial distance track - space point More...
double	distanceChi2 (const Vertex &v1, const Vertex &v2)
	$\chi^2$ distance between two vertices, $ndf = 3$ More...
double	distanceChi2 (const Vertex &v, double x, double y, double z)
	$\chi2$ distance vertex - space point, $ndf = 3$ More...
— Global utility functions —
template<class T >
const T	sqr (const T &x)
	compute the square of a number: $x*x$ More...
template<class T >
const short int	sgn (const T &x)
	compute the sign of a number More...
template<class T >
const T	max (const T &rhs, const T &lhs)
template<class T >
const T	min (const T &rhs, const T &lhs)

Typedef Documentation

const_iterator

typedef ConstRelationIterator VERTEX::const_iterator

const_reverse_iterator

typedef ConstReverseRelationIterator VERTEX::const_reverse_iterator

iterator

typedef RelationIterator VERTEX::iterator

MassC_cit

typedef std::list<MassC*>::const_iterator VERTEX::MassC_cit

MassC_it

typedef std::list<MassC*>::iterator VERTEX::MassC_it

MassC_v

typedef std::list<MassC*> VERTEX::MassC_v

Rel_cit

typedef std::vector<Relation*>::const_iterator VERTEX::Rel_cit

Rel_it

typedef std::vector<Relation*>::iterator VERTEX::Rel_it

Rel_v

typedef std::vector<Relation*> VERTEX::Rel_v

Relation_cit

typedef std::list<Relation*>::const_iterator VERTEX::Relation_cit

Relation_it

typedef std::list<Relation*>::iterator VERTEX::Relation_it

Relation_rcit

typedef std::list<Relation*>::const_reverse_iterator VERTEX::Relation_rcit

Relation_rit

typedef std::list<Relation*>::reverse_iterator VERTEX::Relation_rit

Relation_v

typedef std::list<Relation*> VERTEX::Relation_v

reverse_iterator

typedef ReverseRelationIterator VERTEX::reverse_iterator

Track_cit

typedef std::vector<Track*>::const_iterator VERTEX::Track_cit

Track_it

typedef std::vector<Track*>::iterator VERTEX::Track_it

Track_v

typedef std::vector<Track*> VERTEX::Track_v

Vector_d

typedef std::vector<double> VERTEX::Vector_d

Function Documentation

createRelation()

bool VERTEX::createRelation	(	Track &	t,
		Vertex &	v
	)

                                           {
    //    cout << " Create Relation called!! " << &t << " " << &v << endl;
    Relation* rel = new Relation(t,v);
    t.push__back(rel);
    v.push__back(rel);
    return true;
  }

distance() [1/2]

double VERTEX::distance	(	const Track &	t,
		const Vertex &	v
	)

spatial distance track - vertex

                                                   {
    double dx = v.vx() - t.x();
    double dy = v.vy() - t.y();
    double dz = v.vz() - t.z();
    double tx = t.tx();
    double ty = t.ty();
    double nom = sqr(dx*ty - dy*tx) + sqr(dy - dz*ty) + sqr(dz*tx - dx);
    double denom = sqr(tx) + sqr(ty) + 1.;
    return sqrt(nom/denom);
  }

distance() [2/2]

double VERTEX::distance ( const Vertex &  v, const Track &  t  )

inline

{ return distance(t,v); }

distanceChi2() [1/3]

double VERTEX::distanceChi2	(	const Vertex &	v,
		double	x,
		double	y,
		double	z
	)

$\chi2$ distance vertex - space point, $ndf = 3$

                                                                     {
    return v.distance(x,y,z);
  }

distanceChi2() [2/3]

double VERTEX::distanceChi2	(	const Vertex &	v1,
		const Vertex &	v2
	)

$\chi^2$ distance between two vertices, $ndf = 3$

                                                          {
    return v1.distance(v2);
  }

distanceChi2() [3/3]

double VERTEX::distanceChi2	(	Track &	t1,
		Track &	t2
	)

$\chi^2$ distance track - track, $ndf = 1$

                                            {
    Vertex tmp(t1,t2);
    tmp.findVertexVt();
    return tmp.chi2();
  }

max()

template<class T >

const T VERTEX::max ( const T &  rhs, const T &  lhs  )

inline

                                                 {
    return (rhs > lhs) ? rhs : lhs;
  }

min()

template<class T >

const T VERTEX::min ( const T &  rhs, const T &  lhs  )

inline

                                                 {
    return (rhs < lhs) ? rhs : lhs;
  }

operator<<() [1/7]

std::ostream & VERTEX::operator<<	(	std::ostream &	os,
		const Kalman &	k
	)

operator<<() [2/7]

std::ostream & VERTEX::operator<< ( std::ostream &  os, const Relation &  r  )

inline

                                                                      {
    r.print(os);
    return os;
  }

operator<<() [3/7]

std::ostream & VERTEX::operator<< ( std::ostream &  os, const Track &  t  )

inline

                                                                   {
    return t.print(os);
  }

operator<<() [4/7]

std::ostream & VERTEX::operator<< ( std::ostream &  os, const VtIni &  t  )

inline

                                                                   {
    t.print(os);
    return os;
  }

operator<<() [5/7]

std::ostream & VERTEX::operator<< ( std::ostream &  s, const MassC &  a  )

inline

                                                               {
    a.print(s);
    return s;
  }

operator<<() [6/7]

std::ostream & VERTEX::operator<< ( std::ostream &  s, const RelationList &  a  )

inline

                                                                      {
    a.print(s);
    return s;
  }

operator<<() [7/7]

std::ostream & VERTEX::operator<< ( std::ostream &  s, const Vertex &  a  )

inline

                                                                {
    return a.print(s);
  }

sgn()

template<class T >

const short int VERTEX::sgn ( const T &  x )

inline

compute the sign of a number

{ return (x==0)? 0 : (x<0)? -1 : 1; }

SGNdistance() [1/3]

double VERTEX::SGNdistance	(	const Track &	t,
		const Vertex &	v
	)

signed spatial distance track - vertex

                                                      {
    return SGNdistance(t, v.vx(), v.vy(), v.vz());
  }

SGNdistance() [2/3]

double VERTEX::SGNdistance	(	const Track &	t,
		double	xv,
		double	yv,
		double	zv
	)

signed spatial distance track - space point

                                                                      {
 
    double A  = t.tx();
    double B  = t.ty();
    double C  = 1.;
    double xt = t.x();
    double yt = t.y();
    double zt = t.z();
 
    double denom = A*A + B*B + C*C;
    double nom   = A*(xt-xv) + B*(yt-yv) + C*(zt-zv);
    double rho   = nom / denom;
 
    // point of track closest to Vertex
    double x = xt - A*rho;
    double y = yt - B*rho;
    double z = zt - C*rho;
 
    double dx = x - xv;
    double dy = y - yv;
    double dz = z - zv;
 
    // The sign tells if the point of track closest to 
    // vertex is upstream or downstream the vertex
    return sgn(dz) * sqrt(dx*dx + dy*dy + dz*dz);
  }

SGNdistance() [3/3]

double VERTEX::SGNdistance ( const Vertex &  v, const Track &  t  )

inline

                                                             {
    return SGNdistance(t,v);
  }

sqr()

template<class T >

const T VERTEX::sqr ( const T &  x )

inline

compute the square of a number: $x*x$

{ return x*x; }