[u/mrichter/AliRoot.git] / STEER / AliESDtrack.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//-----------------------------------------------------------------
//           Implementation of the ESD track class
//   This is the class to deal with during the phisical analysis of data
//
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-----------------------------------------------------------------

#include "TMath.h"

#include "AliESDtrack.h"
#include "AliKalmanTrack.h"
#include "../ITS/AliITStrackV2.h"

ClassImp(AliESDtrack)

//_______________________________________________________________________
AliESDtrack::AliESDtrack() : 
fFlags(0), 
fITSncls(0),
fTPCncls(0),
fVertex(kFALSE)
{
  //
  // The default ESD constructor 
  //
  for (Int_t i=0; i<kSPECIES; i++) fR[i]=0.;
}

//_______________________________________________________________________
Float_t AliESDtrack::GetMass() const {
  Float_t max=0.;
  Int_t k=-1;
  for (Int_t i=0; i<kSPECIES; i++) {
    if (fR[i]>max) {k=i; max=fR[i];}
  }
  if (k==0) return 0.00051;
  if (k==1) return 0.10566;
  if (k==2||k==-1) return 0.13957;
  if (k==3) return 0.49368;
  if (k==4) return 0.93827;
  Warning("GetMass()","Undefined mass !");
  return 0.13957;
}

//_______________________________________________________________________
Bool_t AliESDtrack::UpdateTrackParams(AliKalmanTrack *t, ULong_t flags) {
  //
  // This function updates track's running parameters 
  //
  switch (flags) {
    
  case kITSin:
  case kITSout: 
  case kITSrefit:
    fITSncls=t->GetNumberOfClusters();
    fITSchi2=t->GetChi2();
    for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
    fITSsignal=t->GetPIDsignal();
    break;
    
  case kTPCin: case kTPCout: case kTPCrefit:
    fTPCncls=t->GetNumberOfClusters();
    fTPCchi2=t->GetChi2();
    for (Int_t i=0;i<fTPCncls;i++) fTPCindex[i]=t->GetClusterIndex(i);
    fTPCsignal=t->GetPIDsignal();
    {Double_t mass=t->GetMass();    // preliminary mass setting 
    if (mass>0.5) fR[4]=1.;         //        used by
    else if (mass<0.4) fR[2]=1.;    // the ITS reconstruction
    else fR[3]=1.;}                 //
    break;
  case kTRDin: case kTRDout: case kTRDrefit:
    fTRDncls=t->GetNumberOfClusters();
    fTRDchi2=t->GetChi2();
    fTRDsignal=t->GetPIDsignal();
    break;
  default: 
    Error("UpdateTrackParams()","Wrong flag !\n");
    return kFALSE;
  }

  SetStatus(flags);
  fLabel=t->GetLabel();

  if (t->IsStartedTimeIntegral()) {
    SetStatus(kTIME);
    Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
    SetIntegratedLength(t->GetIntegratedLength());
  }

  fRalpha=t->GetAlpha();
  t->GetExternalParameters(fRx,fRp);
  t->GetExternalCovariance(fRc);
  
  if (flags == kITSin)
   {
     AliITStrackV2* itstrack = dynamic_cast<AliITStrackV2*>(t);
     if (itstrack)
      {
        itstrack->PropagateTo(3.,0.0028,65.19);
        itstrack->PropagateToVertex();
        
        Double_t ralpha=t->GetAlpha();
        Double_t rx;      // X-coordinate of the track reference plane 
        Double_t rp[5];   // external track parameters  
        t->GetExternalParameters(rx,rp);
   
        Double_t phi=TMath::ASin(rp[2]) + ralpha;
        Double_t pt=1./TMath::Abs(rp[4]);
        Double_t r=TMath::Sqrt(rx*rx + rp[0]*rp[0]);
        
        fVertexX=r*TMath::Cos(phi); 
        fVertexY=r*TMath::Sin(phi); 
        fVertexZ=rp[1]; 
        
        fVertexPx = pt*TMath::Cos(phi); 
        fVertexPy = pt*TMath::Sin(phi); 
        fVertexPz = pt*rp[3]; 
        fVertex = kTRUE;
      }
   }
  
  return kTRUE;
}

//_______________________________________________________________________
void AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
  //---------------------------------------------------------------------
  // This function returns external representation of the track parameters
  // at the plane x
  //---------------------------------------------------------------------
  Double_t dx=x-fRx;
  Double_t c=fRp[4]/AliKalmanTrack::GetConvConst();
  Double_t f1=fRp[2], f2=f1 + c*dx;
  Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2);    

  p[0]=fRp[0]+dx*(f1+f2)/(r1+r2);
  p[1]=fRp[1]+dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
  p[2]=fRp[2]+dx*c;
  p[3]=fRp[3];
  p[4]=fRp[4];
}

//_______________________________________________________________________
void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
  //---------------------------------------------------------------------
  // This function returns external representation of the track parameters
  //---------------------------------------------------------------------
  x=fRx;
  for (Int_t i=0; i<5; i++) p[i]=fRp[i];
}

Double_t AliESDtrack::GetP() const {
  //---------------------------------------------------------------------
  // This function returns the track momentum
  //---------------------------------------------------------------------
  Double_t lam=TMath::ATan(fRp[3]);
  Double_t pt=1./TMath::Abs(fRp[4]);
  return pt/TMath::Cos(lam);
}

void AliESDtrack::GetPxPyPz(Double_t *p) const {
  //---------------------------------------------------------------------
  // This function returns the global track momentum components
  //---------------------------------------------------------------------
  Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
  Double_t pt=1./TMath::Abs(fRp[4]);
  p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fRp[3]; 
}

void AliESDtrack::GetXYZ(Double_t *xyz) const {
  //---------------------------------------------------------------------
  // This function returns the global track position
  //---------------------------------------------------------------------
  Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
  Double_t r=TMath::Sqrt(fRx*fRx + fRp[0]*fRp[0]);
  xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fRp[1]; 
}

//_______________________________________________________________________
void AliESDtrack::GetExternalCovariance(Double_t c[15]) const {
  //---------------------------------------------------------------------
  // This function returns external representation of the cov. matrix
  //---------------------------------------------------------------------
  for (Int_t i=0; i<15; i++) c[i]=fRc[i];
}

//_______________________________________________________________________
void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
  for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
}

//_______________________________________________________________________
void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
  for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
}

//_______________________________________________________________________
void AliESDtrack::SetITSpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
  SetStatus(AliESDtrack::kITSpid);
}

//_______________________________________________________________________
void AliESDtrack::GetITSpid(Double_t *p) const {
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
}

//_______________________________________________________________________
Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
  //---------------------------------------------------------------------
  // This function returns indices of the assgined ITS clusters 
  //---------------------------------------------------------------------
  for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
  return fITSncls;
}

//_______________________________________________________________________
Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
  //---------------------------------------------------------------------
  // This function returns indices of the assgined ITS clusters 
  //---------------------------------------------------------------------
  for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i];  // MI I prefer some constant
  return fTPCncls;
}

//_______________________________________________________________________
void AliESDtrack::SetTPCpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
  SetStatus(AliESDtrack::kTPCpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTPCpid(Double_t *p) const {
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
}

//_______________________________________________________________________
void AliESDtrack::SetTRDpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
  SetStatus(AliESDtrack::kTRDpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTRDpid(Double_t *p) const {
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
}

//_______________________________________________________________________
void    AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
{
  fTRDr[iSpecies] = p;
}

Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
{
  return fTRDr[iSpecies];
}

//_______________________________________________________________________
void AliESDtrack::SetTOFpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
  SetStatus(AliESDtrack::kTOFpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTOFpid(Double_t *p) const {
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
}

//_______________________________________________________________________
void AliESDtrack::SetESDpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
  SetStatus(AliESDtrack::kESDpid);
}

//_______________________________________________________________________
void AliESDtrack::GetESDpid(Double_t *p) const {
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
}

void AliESDtrack::GetVertexXYZ(Double_t& x,Double_t& y, Double_t&z) const
{
//returns track position in DCA to vertex  
  x = fVertexX;
  y = fVertexY;
  z = fVertexZ;
}
void AliESDtrack::GetVertexPxPyPz(Double_t& px,Double_t& py, Double_t& pz) const
{
//returns track momentum in DCA to vertex  
  px = fVertexPx;
  py = fVertexPy;
  pz = fVertexPz;
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	//-----------------------------------------------------------------
	17	// Implementation of the ESD track class
	18	// This is the class to deal with during the phisical analysis of data
	19	//
	20	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
	21	//-----------------------------------------------------------------
	22
	23	#include "TMath.h"
	24
	25	#include "AliESDtrack.h"
	26	#include "AliKalmanTrack.h"
	27	#include "../ITS/AliITStrackV2.h"
	28
	29	ClassImp(AliESDtrack)
	30
	31	//_______________________________________________________________________
	32	AliESDtrack::AliESDtrack() :
	33	fFlags(0),
	34	fITSncls(0),
	35	fTPCncls(0),
	36	fVertex(kFALSE)
	37	{
	38	//
	39	// The default ESD constructor
	40	//
	41	for (Int_t i=0; i<kSPECIES; i++) fR[i]=0.;
	42	}
	43
	44	//_______________________________________________________________________
	45	Float_t AliESDtrack::GetMass() const {
	46	Float_t max=0.;
	47	Int_t k=-1;
	48	for (Int_t i=0; i<kSPECIES; i++) {
	49	if (fR[i]>max) {k=i; max=fR[i];}
	50	}
	51	if (k==0) return 0.00051;
	52	if (k==1) return 0.10566;
	53	if (k==2\|\|k==-1) return 0.13957;
	54	if (k==3) return 0.49368;
	55	if (k==4) return 0.93827;
	56	Warning("GetMass()","Undefined mass !");
	57	return 0.13957;
	58	}
	59
	60	//_______________________________________________________________________
	61	Bool_t AliESDtrack::UpdateTrackParams(AliKalmanTrack *t, ULong_t flags) {
	62	//
	63	// This function updates track's running parameters
	64	//
	65	switch (flags) {
	66
	67	case kITSin:
	68	case kITSout:
	69	case kITSrefit:
	70	fITSncls=t->GetNumberOfClusters();
	71	fITSchi2=t->GetChi2();
	72	for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
	73	fITSsignal=t->GetPIDsignal();
	74	break;
	75
	76	case kTPCin: case kTPCout: case kTPCrefit:
	77	fTPCncls=t->GetNumberOfClusters();
	78	fTPCchi2=t->GetChi2();
	79	for (Int_t i=0;i<fTPCncls;i++) fTPCindex[i]=t->GetClusterIndex(i);
	80	fTPCsignal=t->GetPIDsignal();
	81	{Double_t mass=t->GetMass(); // preliminary mass setting
	82	if (mass>0.5) fR[4]=1.; // used by
	83	else if (mass<0.4) fR[2]=1.; // the ITS reconstruction
	84	else fR[3]=1.;} //
	85	break;
	86	case kTRDin: case kTRDout: case kTRDrefit:
	87	fTRDncls=t->GetNumberOfClusters();
	88	fTRDchi2=t->GetChi2();
	89	fTRDsignal=t->GetPIDsignal();
	90	break;
	91	default:
	92	Error("UpdateTrackParams()","Wrong flag !\n");
	93	return kFALSE;
	94	}
	95
	96	SetStatus(flags);
	97	fLabel=t->GetLabel();
	98
	99	if (t->IsStartedTimeIntegral()) {
	100	SetStatus(kTIME);
	101	Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
	102	SetIntegratedLength(t->GetIntegratedLength());
	103	}
	104
	105	fRalpha=t->GetAlpha();
	106	t->GetExternalParameters(fRx,fRp);
	107	t->GetExternalCovariance(fRc);
	108
	109	if (flags == kITSin)
	110	{
	111	AliITStrackV2* itstrack = dynamic_cast<AliITStrackV2*>(t);
	112	if (itstrack)
	113	{
	114	itstrack->PropagateTo(3.,0.0028,65.19);
	115	itstrack->PropagateToVertex();
	116
	117	Double_t ralpha=t->GetAlpha();
	118	Double_t rx; // X-coordinate of the track reference plane
	119	Double_t rp[5]; // external track parameters
	120	t->GetExternalParameters(rx,rp);
	121
	122	Double_t phi=TMath::ASin(rp[2]) + ralpha;
	123	Double_t pt=1./TMath::Abs(rp[4]);
	124	Double_t r=TMath::Sqrt(rxrx + rp[0]rp[0]);
	125
	126	fVertexX=r*TMath::Cos(phi);
	127	fVertexY=r*TMath::Sin(phi);
	128	fVertexZ=rp[1];
	129
	130	fVertexPx = pt*TMath::Cos(phi);
	131	fVertexPy = pt*TMath::Sin(phi);
	132	fVertexPz = pt*rp[3];
	133	fVertex = kTRUE;
	134	}
	135	}
	136
	137	return kTRUE;
	138	}
	139
	140	//_______________________________________________________________________
	141	void AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
	142	//---------------------------------------------------------------------
	143	// This function returns external representation of the track parameters
	144	// at the plane x
	145	//---------------------------------------------------------------------
	146	Double_t dx=x-fRx;
	147	Double_t c=fRp[4]/AliKalmanTrack::GetConvConst();
	148	Double_t f1=fRp[2], f2=f1 + c*dx;
	149	Double_t r1=sqrt(1.- f1f1), r2=sqrt(1.- f2f2);
	150
	151	p[0]=fRp[0]+dx*(f1+f2)/(r1+r2);
	152	p[1]=fRp[1]+dx(f1+f2)/(f1r2 + f2r1)fRp[3];
	153	p[2]=fRp[2]+dx*c;
	154	p[3]=fRp[3];
	155	p[4]=fRp[4];
	156	}
	157
	158	//_______________________________________________________________________
	159	void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
	160	//---------------------------------------------------------------------
	161	// This function returns external representation of the track parameters
	162	//---------------------------------------------------------------------
	163	x=fRx;
	164	for (Int_t i=0; i<5; i++) p[i]=fRp[i];
	165	}
	166
	167	Double_t AliESDtrack::GetP() const {
	168	//---------------------------------------------------------------------
	169	// This function returns the track momentum
	170	//---------------------------------------------------------------------
	171	Double_t lam=TMath::ATan(fRp[3]);
	172	Double_t pt=1./TMath::Abs(fRp[4]);
	173	return pt/TMath::Cos(lam);
	174	}
	175
	176	void AliESDtrack::GetPxPyPz(Double_t *p) const {
	177	//---------------------------------------------------------------------
	178	// This function returns the global track momentum components
	179	//---------------------------------------------------------------------
	180	Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
	181	Double_t pt=1./TMath::Abs(fRp[4]);
	182	p[0]=ptTMath::Cos(phi); p[1]=ptTMath::Sin(phi); p[2]=pt*fRp[3];
	183	}
	184
	185	void AliESDtrack::GetXYZ(Double_t *xyz) const {
	186	//---------------------------------------------------------------------
	187	// This function returns the global track position
	188	//---------------------------------------------------------------------
	189	Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
	190	Double_t r=TMath::Sqrt(fRxfRx + fRp[0]fRp[0]);
	191	xyz[0]=rTMath::Cos(phi); xyz[1]=rTMath::Sin(phi); xyz[2]=fRp[1];
	192	}
	193
	194	//_______________________________________________________________________
	195	void AliESDtrack::GetExternalCovariance(Double_t c[15]) const {
	196	//---------------------------------------------------------------------
	197	// This function returns external representation of the cov. matrix
	198	//---------------------------------------------------------------------
	199	for (Int_t i=0; i<15; i++) c[i]=fRc[i];
	200	}
	201
	202	//_______________________________________________________________________
	203	void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
	204	for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
	205	}
	206
	207	//_______________________________________________________________________
	208	void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
	209	for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
	210	}
	211
	212	//_______________________________________________________________________
	213	void AliESDtrack::SetITSpid(const Double_t *p) {
	214	for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
	215	SetStatus(AliESDtrack::kITSpid);
	216	}
	217
	218	//_______________________________________________________________________
	219	void AliESDtrack::GetITSpid(Double_t *p) const {
	220	for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
	221	}
	222
	223	//_______________________________________________________________________
	224	Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
	225	//---------------------------------------------------------------------
	226	// This function returns indices of the assgined ITS clusters
	227	//---------------------------------------------------------------------
	228	for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
	229	return fITSncls;
	230	}
	231
	232	//_______________________________________________________________________
	233	Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
	234	//---------------------------------------------------------------------
	235	// This function returns indices of the assgined ITS clusters
	236	//---------------------------------------------------------------------
	237	for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
	238	return fTPCncls;
	239	}
	240
	241	//_______________________________________________________________________
	242	void AliESDtrack::SetTPCpid(const Double_t *p) {
	243	for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
	244	SetStatus(AliESDtrack::kTPCpid);
	245	}
	246
	247	//_______________________________________________________________________
	248	void AliESDtrack::GetTPCpid(Double_t *p) const {
	249	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
	250	}
	251
	252	//_______________________________________________________________________
	253	void AliESDtrack::SetTRDpid(const Double_t *p) {
	254	for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
	255	SetStatus(AliESDtrack::kTRDpid);
	256	}
	257
	258	//_______________________________________________________________________
	259	void AliESDtrack::GetTRDpid(Double_t *p) const {
	260	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
	261	}
	262
	263	//_______________________________________________________________________
	264	void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
	265	{
	266	fTRDr[iSpecies] = p;
	267	}
	268
	269	Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
	270	{
	271	return fTRDr[iSpecies];
	272	}
	273
	274	//_______________________________________________________________________
	275	void AliESDtrack::SetTOFpid(const Double_t *p) {
	276	for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
	277	SetStatus(AliESDtrack::kTOFpid);
	278	}
	279
	280	//_______________________________________________________________________
	281	void AliESDtrack::GetTOFpid(Double_t *p) const {
	282	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
	283	}
	284
	285	//_______________________________________________________________________
	286	void AliESDtrack::SetESDpid(const Double_t *p) {
	287	for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
	288	SetStatus(AliESDtrack::kESDpid);
	289	}
	290
	291	//_______________________________________________________________________
	292	void AliESDtrack::GetESDpid(Double_t *p) const {
	293	for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
	294	}
	295
	296	void AliESDtrack::GetVertexXYZ(Double_t& x,Double_t& y, Double_t&z) const
	297	{
	298	//returns track position in DCA to vertex
	299	x = fVertexX;
	300	y = fVertexY;
	301	z = fVertexZ;
	302	}
	303	void AliESDtrack::GetVertexPxPyPz(Double_t& px,Double_t& py, Double_t& pz) const
	304	{
	305	//returns track momentum in DCA to vertex
	306	px = fVertexPx;
	307	py = fVertexPy;
	308	pz = fVertexPz;
	309	}