VERTEX Namespace Reference

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; }