EdbVertex Class Reference

#include <EdbVertex.h>

Inheritance diagram for EdbVertex:

Collaboration diagram for EdbVertex:

Public Member Functions
void	AddVTA (EdbVTA *vta)
Int_t	CheckDiscardedTracks ()
float	CheckImp (const EdbTrackP *tr)
EdbVTA *	CheckImp (const EdbTrackP *tr, float ImpMax, int zpos, float dist)
float	CheckImpGeom (const EdbTrackP *tr)
Float_t	Chi2Track (EdbTrackP *tr, int zpos, float X0=0.)
void	Clear ()
void	ClearNeighborhood ()
void	ClearV ()
Int_t	Compare (const TObject *o) const
Float_t	DistSeg (EdbSegP *seg, float X0=0.)
Float_t	DistTrack (EdbTrackP *tr, int zpos, float X0=0.)
void	Edb2Vt (const EdbSegP &s, VERTEX::Track &t, float X0=0., float m=0.139)
void	Edb2Vt (const EdbTrackP &tr, VERTEX::Track &t, float X0=0., float m=0.139)
	EdbVertex ()
Int_t	EstimateVertexFlag ()
Bool_t	EstimateVertexMath (float &xv, float &yv, float &zv, float &d)
Int_t	Flag () const
EdbVertex *	GetConnectedVertex (int nv)
EdbVertex *	GetConnectedVertexForTrack (int it)
EdbVTA *	GetMaxImpVTA ()
EdbTrackP *	GetTrack (int i)
EdbTrackP *	GetTrackN (int i)
EdbSegP *	GetTrackV (int i, bool usesegpar=false)
EdbVTA *	GetVTa (int i)
EdbVTA *	GetVTn (int i)
ULong_t	Hash () const
Int_t	ID () const
Float_t	Impact (int i)
Float_t	ImpTrack (int i)
Bool_t	IsEqual (const TObject *o) const
Bool_t	IsSortable () const
Float_t	MaxAperture ()
Float_t	MaxImpact ()
Int_t	MCEvt () const
EdbTrackP *	MeanTrack ()
Float_t	MinDist ()
Int_t	N () const
Int_t	Nn () const
Int_t	Nv ()
void	Print ()
void	PrintGeom ()
Float_t	Quality ()
void	RemoveVTA (EdbVTA *vta)
void	ResetTracks ()
void	SetFlag (int flag=0)
void	SetID (int ID=0)
void	SetMC (int mEvt=0)
void	SetQuality (float q=0)
void	SetV (VERTEX::Vertex *v)
void	SetXYZ (float x, float y, float z)
Bool_t	TrackInVertex (EdbTrackP *t)
VERTEX::Vertex *	V () const
Float_t	Volume ()
TList *	VTa ()
TList *	VTn ()
Float_t	VX () const
Float_t	VY () const
Float_t	VZ () const
Float_t	X () const
Float_t	Y () const
Float_t	Z () const
Int_t	Zpos (int i)
virtual	~EdbVertex ()

Private Attributes
Int_t	eFlag
Int_t	eID
Int_t	eMCEvt
Float_t	eQuality
VERTEX::Vertex *	eV
TList	eVTa
TList	eVTn
Float_t	eX
Float_t	eY
Float_t	eZ

Constructor & Destructor Documentation

EdbVertex()

EdbVertex::EdbVertex

(

)

{
  eID= 0;
  eV = 0;
  eX = 0.;
  eY = 0.;
  eZ = 0.;
  eFlag = 0;
  eQuality=0.;
  eMCEvt=-999;
}

~EdbVertex()

EdbVertex::~EdbVertex ( )

virtual

{
  Clear();
}

Member Function Documentation

AddVTA()

void EdbVertex::AddVTA

(

EdbVTA *

vta

)

{
  if(vta->Flag()!=2) eVTn.Add(vta);
  else               eVTa.Add(vta);
}

CheckDiscardedTracks()

Int_t EdbVertex::CheckDiscardedTracks

(

)

{
  int ndsc = 0;
  EdbVTA *vta = 0;
  for (int i=0; i<N(); i++)
  {
    vta = GetVTa(i);
    if (vta) {
      if( GetTrack(i)->Vertex(vta->Zpos()) != this ) ndsc++;
    }
    else ndsc++;
  }
  return ndsc;
}

CheckImp() [1/2]

float EdbVertex::CheckImp

(

const EdbTrackP *

tr

)

{
    Track *t = new Track();
    Vertex *v = this->V();
    Edb2Vt(*tr, *t);
    return distance(*t,*v);
}

CheckImp() [2/2]

EdbVTA * EdbVertex::CheckImp	(	const EdbTrackP *	tr,
		float	ImpMax,
		int	zpos,
		float	dist
	)

{
    EdbVTA *vta = 0;
    EdbTrackP *tr1 = (EdbTrackP *)tr;
    if (!tr) return vta;
    Track *t = new Track();
    Vertex *v = this->V();
    Edb2Vt(*tr, *t);
    float imp = distance(*t,*v);
    if (imp > ImpMax) { delete t; return vta;}
    vta = new EdbVTA(tr1, this);
    vta->SetZpos(zpos);
    vta->SetFlag(0);
    vta->SetImp(imp);
    vta->SetDist(dist);
    AddVTA(vta);
    delete t;
    return vta;
}

CheckImpGeom()

float EdbVertex::CheckImpGeom

(

const EdbTrackP *

tr

)

{
    float pv[3] = {VX(), VY(), VZ()};
    float p1[3] = { tr->X(), tr->Y(), tr->Z() };
    float p2[3] = { tr->X() + tr->TX()*1000., tr->Y() + tr->TY()*1000., tr->Z()+1000. };
    bool inside=0;
    float imp = EdbMath::DistancePointLine3(pv, p1,p2, &inside);
    return imp;
}

Chi2Track()

float EdbVertex::Chi2Track	(	EdbTrackP *	tr,
		int	zpos,
		float	X0 = 0.
	)

{
  // Chi2-distance from track to already existing vertex
 
  if (!track) return 0.;
  double distchi2 = -2.;
  EdbSegP *seg = track->TrackExtremity( zpos); // usesegpar??
  if (eV)
    {
      if (track->NF() <= 0) return -1.;
      if (track->P() <= 0.) track->SetP(1.);
      if (track->M() <= 0.) track->SetM(.1395);
      if (track->SP() <= 0.) track->SetErrorP(1.);
      Track *t=new Track();
      Edb2Vt( *seg, *t, X0, track->M() );
      distchi2 = -3.;
      if (eV->valid())
    {
      t->rm(track->M());
      distchi2 = eV->distance(*t);
    } 
      SafeDelete(t);
    }
  return (float)distchi2;
}

Clear()

void EdbVertex::Clear

(

)

{
  eVTa.Delete("slow");
  eVTn.Delete("slow");
  ClearV();
  eX = 0.;
  eY = 0.;
  eZ = 0.;
  eID = 0;
  eFlag = 0;
  eQuality = 0.;
  eMCEvt=-999;
}

ClearNeighborhood()

void EdbVertex::ClearNeighborhood

(

)

{
  int nn = Nn();
  if (nn>0) eVTn.Clear("nodelete");
  for(int i=0; i<nn; i++) delete GetVTn(i);
}

ClearV()

void EdbVertex::ClearV

(

)

{
  //clear VtVertex object
  if (eV) {
    eV->clear();     // should delete also tracks ownered by vertex
    SafeDelete(eV);
  }
}

Compare()

int EdbVertex::Compare

(

const TObject *

o

)

const

{
    /*printf("Inside compare\n");*/
    if      ( eQuality >  ((EdbVertex *)o)->eQuality )  return -1;
    else if ( eQuality == ((EdbVertex *)o)->eQuality )  return  0;
    else                                return  1;
}

DistSeg()

float EdbVertex::DistSeg	(	EdbSegP *	seg,
		float	X0 = 0.
	)

{
  // distance from segment to already fitted vertex
  if(seg)   
    if(eV)  
      if(eV->valid()) {
    Track t;
    Edb2Vt( *seg, t, X0, 0. );
    return (float)distance(t, *eV);
      }
  return 100000.;
}

DistTrack()

float EdbVertex::DistTrack	(	EdbTrackP *	tr,
		int	zpos,
		float	X0 = 0.
	)

{
  // distance from track to already fitted vertex
  if (!track) return 0.;
  EdbSegP *seg = track->TrackExtremity( zpos); // usesegpar??
  if (!seg)  return 0.;
  return DistSeg(seg,X0);
}

Edb2Vt() [1/2]

void EdbVertex::Edb2Vt	(	const EdbSegP &	s,
		VERTEX::Track &	t,
		float	X0 = 0.,
		float	m = 0.139
	)

{
  // Input: EdbSegP tr - track parameters near vertex
  //        X0         - rad length for ms estimation
  //        m          - mass of the particle
  //          if X0 or m are negative - ignore multiple scattering
  // Output: VERTEX:Track t - object propagated to the vertex position with the estimated errors matrix
  // Used: eX,eY,eZ - the reference point of this vertex
 
  double dz = eZ - tr.Z();
  double tx = (double)tr.TX();
  double ty = (double)tr.TY();
  double x  = (double)tr.X() + tx*dz - eX;
  double y  = (double)tr.Y() + ty*dz - eY;
  double z  = 0.;
  float  p  = tr.P();
 
  VtSymMatrix dms(4);   // multiple scattering matrix
  dms.clear();
  if ( X0 > 0. && m > 0.)
    {
      double dPb = dz*TMath::Sqrt(1.+tx*tx+ty*ty); // thickness of the Pb+emulsion cell in microns
      double theta0sq = EdbPhysics::ThetaMS2( p, m, dPb, X0 );
      //printf("( p, m, dPb, X0 dz) = %f %f %f %f %f theta0 = %g\n", p, m, dPb, X0, dz, TMath::Sqrt(theta0sq));
      dms(0,0) = theta0sq*dz*dz/3.;
      dms(1,1) = dms(0,0);
      dms(2,2) = theta0sq;
      dms(3,3) = dms(2,2);
      dms(2,0) = theta0sq*dz/2.;
      dms(3,1) = dms(2,0);
      dms(0,2) = dms(2,0);
      dms(1,3) = dms(2,0);
    }
 
  VtSqMatrix pred(4);        //propagation matrix for track parameters (x,y,tx,ty)
  pred.clear();
  pred(0,0) = 1.;
  pred(1,1) = 1.;
  pred(2,2) = 1.;
  pred(3,3) = 1.;
  pred(0,2) = dz;
  pred(1,3) = dz;
 
  VtSymMatrix cov(4);             // covariance matrix for seg0
  for(int k=0; k<4; k++) 
    for(int l=0; l<4; l++) cov(k,l) = (tr.COV())(k,l);
 
  VtSymMatrix covpred(4);         // covariance matrix for prediction
  covpred = pred*(cov*(pred.T()))+dms;
 
  CMatrix covp;             // covariance matrix for the track
  covp.clear();
  for(int k=0; k<4; k++) 
    for(int l=0; l<4; l++) covp(k,l) = covpred(k,l);
  covp(4,4) = (tr.COV())(4,4);
 
  t.set(x,  y,  z,  tx,  ty,  (double)p, covp);
  t.rm((double)m);
}

Edb2Vt() [2/2]

void EdbVertex::Edb2Vt	(	const EdbTrackP &	tr,
		VERTEX::Track &	t,
		float	X0 = 0.,
		float	m = 0.139
	)

{
  Edb2Vt( *((EdbSegP*)&tr), t, X0, m);
}

EstimateVertexFlag()

Int_t EdbVertex::EstimateVertexFlag

(

)

{
  int flag=-1;
  int n0 = 0, n1=0, nn=0;
  EdbVTA *vta = 0;
  for (int i=0; i<N(); i++)
  {
    vta = GetVTa(i);
    if     ( vta->Zpos()==0 ) n0++;
    else if( vta->Zpos()==1 ) n1++;
    else                      nn++;
  }
 
  if      ( n0>0 && n1 >0)    flag=1;         // end   & start
  else if ( n0==0 && n1>0)    flag=0;         // start & start
  else if ( n0>0 && n1==0)    flag=2;         // end   & end
  else   flag= -1;
  if(nn) flag= -1;              // flag -1 should newer happened: if so - should be debugged
 
  SetFlag(flag);
  Log(3,"EdbVertex::EstimateVertexFlag","%d   with n0=%d n1=%d, nn=%d", flag, n0,n1,nn );
  return flag;
}

EstimateVertexMath()

bool EdbVertex::EstimateVertexMath	(	float &	xv,
		float &	yv,
		float &	zv,
		float &	d
	)

{
  int nt = N(); 
  if(!nt) return false;
 
  double tx_sum  = 0.;
  double x_sum   = 0.;
  double xw_sum  = 0.;
  double xtx_sum = 0.;
  double tx2_sum = 0.;
  double ty_sum  = 0.;
  double y_sum   = 0.;
  double yw_sum  = 0.;
  double yty_sum = 0.;
  double ty2_sum = 0.;
  const EdbTrackP  *tr = 0;
  const EdbSegP    *seg = 0;
 
  double x,y,tx,ty,xweight,yweight,xweight2,yweight2;
 
  // fill cumulants
  for( int i = 0; i < nt; i++ ) {
    
    tr = GetTrack(i);
 
    seg = tr->TrackExtremity( Zpos(i)); // usesegpar??
 
    x        = seg->X();
    y        = seg->Y();
    tx       = seg->TX();
    ty       = seg->TY();
    xweight  = 1./(seg->COV())(0,0);
    yweight  = 1./(seg->COV())(1,1);
    xweight2 = xweight*xweight;
    yweight2 = yweight*yweight;
 
    tx_sum  += tx * xweight;
    x_sum   += x  * xweight;
    xw_sum  += xweight;
    xtx_sum += x  * tx * xweight2;
    tx2_sum += tx * tx * xweight2;
 
    ty_sum  += ty * yweight;
    y_sum   += y  * yweight;
    yw_sum  += yweight;
    yty_sum += y  * ty * yweight2;
    ty2_sum += ty * ty * yweight2;
 
  } // for track
 
  double det = -tx2_sum - ty2_sum + tx_sum*tx_sum/xw_sum + ty_sum*ty_sum/yw_sum;
 
  if(det == 0.) {
    return false;
  }
 
  zv = ( xtx_sum + yty_sum - tx_sum*x_sum/xw_sum - ty_sum*y_sum/yw_sum ) / det;
  xv = ( x_sum + tx_sum * zv ) / xw_sum;
  yv = ( y_sum + ty_sum * zv ) / yw_sum;
 
 
//   float zTolerance=300.;
 
//   for( int i = 0; i < nt; i++ ) {
//       tr = GetTrack(i);
//       if (Zpos(i)) seg = tr->TrackZmin();
//       else      seg = tr->TrackZmax();
//       if( zv > (seg->Z() + zTolerance) )  return false;
//       if( zv < (seg->Z() - zTolerance) )  return false;
//   }
 
  double drx;
  double dry;
  double drz;
  double drt;
  double drms = 0.;
 
  for( int i = 0; i < nt; i++ ) {
 
    tr = GetTrack(i);
 
     seg = tr->TrackExtremity( Zpos(i)); // usesegpar??
    
    drx = seg->X() - xv;
    dry = seg->Y() - yv;
    drz = seg->Z() - zv;
    drt = (drx*seg->TX() + dry*seg->TY() + drz);
    drms += drx*drx + dry*dry + drz*drz -
      (drt*drt)/(1.+seg->TX()*seg->TX()+seg->TY()*seg->TY());
  }
 
  d = TMath::Sqrt(drms/nt);
 
  return true;
}

Flag()

Int_t EdbVertex::Flag ( ) const

inline

{return eFlag;}

GetConnectedVertex()

EdbVertex * EdbVertex::GetConnectedVertex

(

int

nv

)

{
    EdbTrackP *tr = 0;
    EdbVertex *vc = 0;
    int n = 0;
    for (int i=0; i<N(); i++)
    {
    if ((tr = GetTrack(i)))
    {
        if      ((Zpos(i) == 1) && (vc = tr->VertexE()))
        {
        if (n == nv) return vc;
        n++;
        }
        else if ((Zpos(i) == 0) && (vc = tr->VertexS()))
        {
        if (n == nv) return vc;
        n++;
        }
    }
    }
    return 0;
}

GetConnectedVertexForTrack()

EdbVertex * EdbVertex::GetConnectedVertexForTrack

(

int

it

)

{
    EdbTrackP *tr = 0;
    EdbVertex *vc = 0;
    if (it<N())
    {
    if ((tr = GetTrack(it)))
    {
        if      ((Zpos(it) == 1) && (vc = tr->VertexE()))
        {
        return vc;
        }
        else if ((Zpos(it) == 0) && (vc = tr->VertexS()))
        {
        return vc;
        }
    }
    }
    return 0;
}

GetMaxImpVTA()

EdbVTA * EdbVertex::GetMaxImpVTA

(

)

{
// return vta with a biggest impact par
  int ntr = N();
  EdbVTA *maxvta=0;
  if(ntr<1)       maxvta=0;
  else if(ntr==1) maxvta=GetVTa(0);
  else {
    float maximp=0;
    for(int i=0; i<ntr; i++) {
      EdbVTA *vta = GetVTa(i);
      float   imp = vta->Imp();
      if( imp > maximp )  { maximp=imp; maxvta=vta; }
    }
  }
  return maxvta;
}

GetTrack()

EdbTrackP* EdbVertex::GetTrack ( int  i )

inline

{return GetVTa(i)->GetTrack();}

GetTrackN()

EdbTrackP* EdbVertex::GetTrackN ( int  i )

inline

{return GetVTn(i)->GetTrack();}

GetTrackV()

EdbSegP * EdbVertex::GetTrackV	(	int	i,
		bool	usesegpar = false
	)

{
    EdbTrackP *t = GetTrack(i); if(!t) return 0;
    EdbSegP *s = t->TrackExtremity(Zpos(i), usesegpar);
  if( s->P()>=0 && (s->P() != t->P()) ) Log(1,"GetTrackV","Warning! segment momentum=%f is not equal to the track momentum=%f",s->P(), t->P() );
    return s;
}

GetVTa()

EdbVTA* EdbVertex::GetVTa ( int  i )

inline

{return (EdbVTA*)(eVTa.At(i));}

GetVTn()

EdbVTA* EdbVertex::GetVTn ( int  i )

inline

{return (EdbVTA*)(eVTn.At(i));}

Hash()

ULong_t EdbVertex::Hash ( ) const

inline

{return eID;}

ID()

Int_t EdbVertex::ID ( ) const

inline

{return eID;}

Impact()

Float_t EdbVertex::Impact ( int  i )

inline

{ return GetVTa(i)?  GetVTa(i)->Imp(): 1000000.; }

ImpTrack()

Float_t EdbVertex::ImpTrack ( int  i )

inline

{ return DistSeg( GetTrackV(i) ); }

IsEqual()

bool EdbVertex::IsEqual

(

const TObject *

o

)

const

{
    /*printf("Inside isequal\n");*/
    if   ( eID      != ((EdbVertex *)o)->eID )      return false;
    if   ( eQuality != ((EdbVertex *)o)->eQuality ) return false;
    else                                    return true;
}

IsSortable()

Bool_t EdbVertex::IsSortable ( ) const

inline

{return kTRUE;}

MaxAperture()

float EdbVertex::MaxAperture

(

)

{
  float aper=0.;
  int   ntr = N();
  if(ntr<2)                      return aper;
  EdbTrackP *t1=0;
  EdbTrackP *t2=0;
 
  float tx=0,ty=0,a=0;
  for (int i=0; i<ntr-1; i++) {
    t1 = GetTrack(i);
    for (int j=i+1; j<ntr; j++) {
      t2 = GetTrack(j);
 
      tx= t1->TX() - t2->TX();
      ty= t1->TY() - t2->TY();
      a = TMath::Sqrt( tx*tx+ty*ty );
      if( a>aper) aper=a;
    }
  }
  return aper;
}

MaxImpact()

Float_t EdbVertex::MaxImpact ( )

inline

{ EdbVTA *vta=GetMaxImpVTA(); return vta? vta->Imp(): 0; }

MCEvt()

Int_t EdbVertex::MCEvt ( ) const

inline

{return eMCEvt;}

MeanTrack()

EdbTrackP * EdbVertex::MeanTrack

(

)

{
  // calculate mean track trajectory waited with momentum
  int ntr = N();
  EdbTrackP *mean = new EdbTrackP();
  float psum=0;
  for(int i=0; i<ntr; i++) {
    EdbTrackP *t = GetTrack(i);
    mean->Set( 0 , mean->X()  + t->X()*t->P()
                 , mean->Y()  + t->Y()*t->P()
                 , mean->TX() + t->TX()*t->P()
                 , mean->TY() + t->TY()*t->P()
                 , mean->W()  + t->W()*t->P()
                 , 0 );
    mean->SetZ( mean->Z()  + t->Z()*t->P() );
    psum += t->P();
  }
  mean->Set( 0 , mean->X()  / psum
               , mean->Y()  / psum
               , mean->TX() / psum
               , mean->TY() / psum
               , mean->W()  / psum
               , 0 );
  mean->SetZ( mean->Z() / psum );
  mean->SetP(psum);
  return mean;
}

MinDist()

Float_t EdbVertex::MinDist

(

)

{
  float mind=999999999999.;
  int   ntr = N();
  if(ntr<2)                      return mind;
  for (int i=0; i<ntr; i++) {
    float d = GetVTa(i)->Dist();
    if(Abs(d)<mind) mind = Abs(d);
  }
  return mind;
}

N()

Int_t EdbVertex::N ( ) const

inline

{return eVTa.GetSize();}

Nn()

Int_t EdbVertex::Nn ( ) const

inline

{return eVTn.GetSize();}

Nv()

int EdbVertex::Nv

(

)

{
  // return the number of linked vertex: tracks attached by the other edge to the different vertex
  EdbTrackP *tr = 0;
  EdbVertex *vc = 0;
  int nv = 0;
  for (int i=0; i<N(); i++)
    {
      if ((tr = GetTrack(i))) {
    if      ((Zpos(i) == 1) && (vc = tr->VertexE())) nv++;
    else if ((Zpos(i) == 0) && (vc = tr->VertexS())) nv++;
      }
    }
  return nv;
}

Print()

void EdbVertex::Print

(

)

{
    int ntr = N();
    printf( "\n********************** Vertex %d  with flag %d   and %d tracks **************************\n", ID(), Flag(), ntr );
    printf( "Fit quality     : probability = %f    Chi2 = %f\n", V()->prob(), V()->chi2() );
    printf( "Vertex Position : %12.3f %12.3f %12.3f \n", VX(), VY(), VZ() );
    printf( "Position Errors : %12.3f %12.3f %12.3f\n", V()->vxerr(), V()->vyerr(), V()->vzerr() );
    //printf("---------------------------------------------------------\n");
    printf( "Track   ID   Nseg   Mass       P       Chi2/ndf    Prob     Chi2Contrib   Impact         Ztr\n");
    for(int i=0; i<ntr; i++) {
        EdbTrackP *tr = GetTrack(i);
        float ztr =  tr->TrackExtremity( Zpos(i) )->Z();
        printf("%4d  %4d  %4d   %7.4f  %7.2f    %5.2f     %7.4f      %7.3f   %8.2f   %10.2f\n",
               i, tr->ID(), tr->N(), tr->M(), tr->P(),
               tr->Chi2()/tr->N(), tr->Prob(), V()->track_chi2(i), Impact(i), ztr );
    }
    /*
    printf("------- mean \"jet\" direction: ---------\n");
    EdbTrackP *mean = MeanTrack();
    printf("         X            Y            Z       TX       TY         P\n");
    printf("%12.1f %12.1f %12.1f %8.4f %8.4f %10.2f\n", 
            mean->X(), mean->Y(), mean->Z(), mean->TX(), mean->TY(), mean->P() );
    SafeDelete(mean);
    */
    printf("****************************************************************************************\n");
}

PrintGeom()

void EdbVertex::PrintGeom

(

)

{
  int ntr = N();
  printf( "\n********************** Vertex %d  with flag %d   and %d tracks ****************************\n",
      ID(), Flag(), ntr );
  printf( "Fit quality     : probability = %f    Chi2 = %f\n", V()->prob(), V()->chi2() );
  printf( "Vertex Position : %12.2f %12.2f %12.2f \n", VX(), VY(), VZ() );
  printf( "Track  Nseg     TX     TY           zmin          zmax        plmin     plmax        Impact\n");
  for(int i=0; i<ntr; i++) {
    EdbTrackP *tr = GetTrack(i);
    int   nseg = tr->N();
    float zmin=tr->GetSegment(0)->Z();
    float zmax=tr->GetSegment(nseg-1)->Z();
    int   plmin=tr->GetSegment(0)->ScanID().GetPlate();
    int   plmax=tr->GetSegment(nseg-1)->ScanID().GetPlate();
    printf("%4d  %4d  %7.3f %7.3f   %12.2f  %12.2f    %5d     %5d      %10.3f\n",
    i, tr->N(), tr->TX(), tr->TY(), zmin, zmax, plmin, plmax, Impact(i) );
  }
  printf("********************************************************************************************\n");
}

Quality()

Float_t EdbVertex::Quality ( )

inline

{return eQuality;}

RemoveVTA()

void EdbVertex::RemoveVTA

(

EdbVTA *

vta

)

{
  if(vta->Flag()!=2) eVTn.Remove(vta);
  else               eVTa.Remove(vta);
}

ResetTracks()

void EdbVertex::ResetTracks

(

)

{
  // Assign the eVTAS or eVTAE of the tracks to the current vertex
  EdbVTA *vta = 0;
  for (int i=0; i<N(); i++)
  {
    vta = GetVTa(i);
    if (vta) GetTrack(i)->AddVTA(vta);
  }
}

SetFlag()

void EdbVertex::SetFlag ( int  flag = 0 )

inline

{eFlag = flag;}

SetID()

void EdbVertex::SetID ( int  ID = 0 )

inline

{eID = ID;}

SetMC()

void EdbVertex::SetMC ( int  mEvt = 0 )

inline

{eMCEvt=mEvt;}

SetQuality()

void EdbVertex::SetQuality ( float  q = 0 )

inline

{eQuality = q;}

SetV()

void EdbVertex::SetV ( VERTEX::Vertex *  v )

inline

{eV=v;}

SetXYZ()

void EdbVertex::SetXYZ ( float  x, float  y, float  z  )

inline

{eX=x; eY=y; eZ=z;} 

TrackInVertex()

Bool_t EdbVertex::TrackInVertex

(

EdbTrackP *

t

)

{
  int   ntr = N();
  if(!ntr) return 0;
  for (int i=0; i<ntr; i++)  if(t == GetTrack(i)) return 1;
  return 0;
}

V()

VERTEX::Vertex* EdbVertex::V ( ) const

inline

{return eV;}

Volume()

Float_t EdbVertex::Volume ( )

inline

{ if(V()) return V()->vxerr()*V()->vyerr()*V()->vzerr(); else return 0; }

VTa()

TList* EdbVertex::VTa ( )

inline

{return &eVTa;}

VTn()

TList* EdbVertex::VTn ( )

inline

{return &eVTn;} 

VX()

Float_t EdbVertex::VX ( ) const

inline

{return eV ? (eV->vx() + eX) : 1000000.;}

VY()

Float_t EdbVertex::VY ( ) const

inline

{return eV ? (eV->vy() + eY) : 1000000.;}

VZ()

Float_t EdbVertex::VZ ( ) const

inline

{return eV ? (eV->vz() + eZ) : 1000000.;}

X()

Float_t EdbVertex::X ( ) const

inline

{return eX;}

Y()

Float_t EdbVertex::Y ( ) const

inline

{return eY;}

Z()

Float_t EdbVertex::Z ( ) const

inline

{return eZ;}

Zpos()

Int_t EdbVertex::Zpos ( int  i )

inline

{return GetVTa(i)->Zpos();}

Member Data Documentation

eFlag

Int_t EdbVertex::eFlag

private

eID

Int_t EdbVertex::eID

private

eMCEvt

Int_t EdbVertex::eMCEvt

private

eQuality

Float_t EdbVertex::eQuality

private

eV

VERTEX::Vertex* EdbVertex::eV

private

eVTa

TList EdbVertex::eVTa

private

eVTn

TList EdbVertex::eVTn

private

eX

Float_t EdbVertex::eX

private

eY

Float_t EdbVertex::eY

private

eZ

Float_t EdbVertex::eZ

private

---

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

• src/libEdr/EdbVertex.h
• src/libEdr/EdbVertex.cxx