AliTRDtrackV1::AliTRDtrackV1() : AliKalmanTrack()
,fStatus(0)
,fDE(0.)
- ,fReconstructor(0x0)
- ,fBackupTrack(0x0)
- ,fTrackLow(0x0)
- ,fTrackHigh(0x0)
+ ,fkReconstructor(NULL)
+ ,fBackupTrack(NULL)
+ ,fTrackLow(NULL)
+ ,fTrackHigh(NULL)
{
//
// Default constructor
for(int ip=0; ip<kNplane; ip++){
fTrackletIndex[ip] = 0xffff;
- fTracklet[ip] = 0x0;
+ fTracklet[ip] = NULL;
}
}
AliTRDtrackV1::AliTRDtrackV1(const AliTRDtrackV1 &ref) : AliKalmanTrack(ref)
,fStatus(ref.fStatus)
,fDE(ref.fDE)
- ,fReconstructor(ref.fReconstructor)
- ,fBackupTrack(0x0)
- ,fTrackLow(0x0)
- ,fTrackHigh(0x0)
+ ,fkReconstructor(ref.fkReconstructor)
+ ,fBackupTrack(NULL)
+ ,fTrackLow(NULL)
+ ,fTrackHigh(NULL)
{
//
// Copy constructor
AliTRDtrackV1::AliTRDtrackV1(const AliESDtrack &t) : AliKalmanTrack()
,fStatus(0)
,fDE(0.)
- ,fReconstructor(0x0)
- ,fBackupTrack(0x0)
- ,fTrackLow(0x0)
- ,fTrackHigh(0x0)
+ ,fkReconstructor(NULL)
+ ,fBackupTrack(NULL)
+ ,fTrackLow(NULL)
+ ,fTrackHigh(NULL)
{
//
// Constructor from AliESDtrack
SetLabel(t.GetLabel());
SetChi2(0.0);
- SetMass(t.GetMass());
+
+ SetMass(t.GetMass()/*0.000510*/);
AliKalmanTrack::SetNumberOfClusters(t.GetTRDncls());
Int_t ti[kNplane]; t.GetTRDtracklets(&ti[0]);
for(int ip=0; ip<kNplane; ip++){
fTrackletIndex[ip] = ti[ip] < 0 ? 0xffff : ti[ip];
- fTracklet[ip] = 0x0;
+ fTracklet[ip] = NULL;
}
for(int i =0; i<3; i++) fBudget[i] = 0.;
}
//_______________________________________________________________
-AliTRDtrackV1::AliTRDtrackV1(AliTRDseedV1 *trklts, const Double_t p[5], const Double_t cov[15]
+AliTRDtrackV1::AliTRDtrackV1(AliTRDseedV1 * const trklts, const Double_t p[5], const Double_t cov[15]
, Double_t x, Double_t alpha) : AliKalmanTrack()
,fStatus(0)
,fDE(0.)
- ,fReconstructor(0x0)
- ,fBackupTrack(0x0)
- ,fTrackLow(0x0)
- ,fTrackHigh(0x0)
+ ,fkReconstructor(NULL)
+ ,fBackupTrack(NULL)
+ ,fTrackLow(NULL)
+ ,fTrackHigh(NULL)
{
//
// The stand alone tracking constructor
Double_t mostProbablePt=AliExternalTrackParam::GetMostProbablePt();
Double_t p0=TMath::Sign(1/mostProbablePt,pp[4]);
Double_t w0=cc[14]/(cc[14] + p0*p0), w1=p0*p0/(cc[14] + p0*p0);
+ AliDebug(4, Form("Pt mixing : w0[%4.2f] 1/pt0[%5.3f] w1[%4.2f] 1/pt[%5.3f]", w0, 1./p0, w1, 1./pp[4]));
pp[4] = w0*p0 + w1*pp[4];
+
+
cc[10]*=w1; cc[11]*=w1; cc[12]*=w1; cc[13]*=w1; cc[14]*=w1;
Set(x,alpha,pp,cc);
+ AliDebug(2, Form("Init @ x[%6.2f] pt[%5.3f]", x, 1./pp[4]));
Int_t ncls = 0;
for(int iplane=0; iplane<kNplane; iplane++){
fTrackletIndex[iplane] = 0xffff;
- if(!trklts[iplane].IsOK()) fTracklet[iplane] = 0x0;
+ if(!trklts[iplane].IsOK()) fTracklet[iplane] = NULL;
else{
fTracklet[iplane] = &trklts[iplane];
ncls += fTracklet[iplane]->GetN();
//AliInfo("");
//printf("I-AliTRDtrackV1::~AliTRDtrackV1() : Owner[%s]\n", TestBit(kOwner)?"YES":"NO");
- if(fBackupTrack) delete fBackupTrack; fBackupTrack = 0x0;
+ if(fBackupTrack) delete fBackupTrack; fBackupTrack = NULL;
- if(fTrackLow) delete fTrackLow; fTrackLow = 0x0;
- if(fTrackHigh) delete fTrackHigh; fTrackHigh = 0x0;
+ if(fTrackLow) delete fTrackLow; fTrackLow = NULL;
+ if(fTrackHigh) delete fTrackHigh; fTrackHigh = NULL;
for(Int_t ip=0; ip<kNplane; ip++){
if(TestBit(kOwner) && fTracklet[ip]) delete fTracklet[ip];
- fTracklet[ip] = 0x0;
+ fTracklet[ip] = NULL;
fTrackletIndex[ip] = 0xffff;
}
}
Bool_t labelAdded;
Int_t label;
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for (Int_t ip = 0; ip < kNplane; ip++) {
if(fTrackletIndex[ip] == 0xffff) continue;
for (Int_t ic = 0; ic < AliTRDseedV1::kNclusters; ic++) {
//_______________________________________________________________
Bool_t AliTRDtrackV1::CookPID()
{
- //
- // Cook the PID information
- //
+//
+// Cook the PID information for the track by delegating the omonim function of the tracklets.
+// Computes the number of tracklets used. The tracklet information are considered independent.
+// For the moment no global track measurement of PID is performed as for example to estimate
+// bremsstrahlung probability based on global chi2 of the track.
+//
+// The status bit AliESDtrack::kTRDpid is set during the call of AliTRDtrackV1::UpdateESDtrack().The PID performance of the
+//TRD for tracks with 6 tacklets is displayed below.
+//Begin_Html
+//<img src="TRD/trackPID.gif">
+//End_Html
+//
- // Reset the a priori probabilities
+ /*Reset the a priori probabilities*/
Double_t pid = 1. / AliPID::kSPECIES;
for(int ispec=0; ispec<AliPID::kSPECIES; ispec++) fPID[ispec] = pid;
// no tracklet found for PID calculations
if(!fPIDquality) return kFALSE;
- // slot for PID calculation @ track level
+ // slot for PID calculation @ track level for bremsstrahlung TODO
// normalize probabilities
Double_t probTotal = 0.0;
{
// Retrieve number of tracklets used for PID calculation.
- UChar_t fPIDquality = 0;
- Float_t *prob = 0x0;
+ UChar_t nPID = 0;
+ Float_t *prob = NULL;
for(int ip=0; ip<kNplane; ip++){
if(fTrackletIndex[ip] == 0xffff) continue;
if(!fTracklet[ip]->IsOK()) continue;
- if(!(prob = fTracklet[ip]->GetProbability(kFALSE))) return 0;
+ if(!(prob = fTracklet[ip]->GetProbability(kFALSE))) continue;
Int_t nspec = 0; // quality check of tracklet dEdx
for(int ispec=0; ispec<AliPID::kSPECIES; ispec++){
}
if(!nspec) continue;
- fPIDquality++;
+ fTracklet[ip]->SetPID();
+ nPID++;
}
- return fPIDquality;
+ return nPID;
}
//___________________________________________________________
UChar_t fPIDquality = 0;
// steer PID calculation @ tracklet level
- Float_t *prob = 0x0;
+ Float_t *prob = NULL;
for(int ip=0; ip<kNplane; ip++){
if(fTrackletIndex[ip] == 0xffff) continue;
if(!fTracklet[ip]->IsOK()) continue;
//_______________________________________________________________
AliTRDcluster* AliTRDtrackV1::GetCluster(Int_t id)
{
+ // Get the cluster at a certain position in the track
Int_t n = 0;
for(Int_t ip=0; ip<kNplane; ip++){
if(!fTracklet[ip]) continue;
n+=fTracklet[ip]->GetN();
continue;
}
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for(Int_t ic=AliTRDseedV1::kNclusters; ic--;){
if(!(c = fTracklet[ip]->GetClusters(ic))) continue;
return c;
}
}
- return 0x0;
+ return NULL;
}
//_______________________________________________________________
Int_t AliTRDtrackV1::GetClusterIndex(Int_t id) const
{
+ // Get the cluster index at a certain position in the track
Int_t n = 0;
for(Int_t ip=0; ip<kNplane; ip++){
if(!fTracklet[ip]) continue;
n+=fTracklet[ip]->GetN();
continue;
}
- AliTRDcluster *c = 0x0;
+ AliTRDcluster *c = NULL;
for(Int_t ic=AliTRDseedV1::kNclusters; ic--;){
if(!(c = fTracklet[ip]->GetClusters(ic))) continue;
//_______________________________________________________________
Bool_t AliTRDtrackV1::IsEqual(const TObject *o) const
{
+ // Checks whether two tracks are equal
if (!o) return kFALSE;
const AliTRDtrackV1 *inTrack = dynamic_cast<const AliTRDtrackV1*>(o);
if (!inTrack) return kFALSE;
//_______________________________________________________________
Bool_t AliTRDtrackV1::IsElectron() const
{
- if(GetPID(0) > fReconstructor->GetRecoParam()->GetPIDThreshold(GetP())) return kTRUE;
+ if(GetPID(0) > fkReconstructor->GetRecoParam()->GetPIDThreshold(GetP())) return kTRUE;
return kFALSE;
}
{
//
// Find a prolongation at given x
- // Return 0 if it does not exist
+ // Return -1 if it does not exist
//
Double_t bz = GetBz();
- if (!AliExternalTrackParam::GetYAt(xk,bz,y)) return 0;
- if (!AliExternalTrackParam::GetZAt(xk,bz,z)) return 0;
+ if (!AliExternalTrackParam::GetYAt(xk,bz,y)) return -1;
+ if (!AliExternalTrackParam::GetZAt(xk,bz,z)) return -1;
return 1;
// "xrho" - thickness*density [g/cm^2]
//
- if (xk == GetX()) {
- return kTRUE;
- }
-
- Double_t oldX = GetX();
- Double_t oldY = GetY();
- Double_t oldZ = GetZ();
+ if (xk == GetX()) return kTRUE;
- Double_t bz = GetBz();
-
- if (!AliExternalTrackParam::PropagateTo(xk,bz)) {
- return kFALSE;
- }
-
- Double_t x = GetX();
- Double_t y = GetY();
- Double_t z = GetZ();
-
- if (oldX < xk) {
+ Double_t xyz0[3] = {GetX(), GetY(), GetZ()}, // track position BEFORE propagation
+ b[3]; // magnetic field
+ GetBxByBz(b);
+ if(!AliExternalTrackParam::PropagateToBxByBz(xk,b)) return kFALSE;
+
+ // local track position AFTER propagation
+ Double_t xyz1[3] = {GetX(), GetY(), GetZ()};
+ if(xyz0[0] < xk) {
xrho = -xrho;
if (IsStartedTimeIntegral()) {
- Double_t l2 = TMath::Sqrt((x-oldX)*(x-oldX)
- + (y-oldY)*(y-oldY)
- + (z-oldZ)*(z-oldZ));
- Double_t crv = AliExternalTrackParam::GetC(bz);
+ Double_t l2 = TMath::Sqrt((xyz1[0]-xyz0[0])*(xyz1[0]-xyz0[0])
+ + (xyz1[1]-xyz0[1])*(xyz1[1]-xyz0[1])
+ + (xyz1[2]-xyz0[2])*(xyz1[2]-xyz0[2]));
+ Double_t crv = AliExternalTrackParam::GetC(b[3]);
if (TMath::Abs(l2*crv) > 0.0001) {
// Make correction for curvature if neccesary
- l2 = 0.5 * TMath::Sqrt((x-oldX)*(x-oldX)
- + (y-oldY)*(y-oldY));
+ l2 = 0.5 * TMath::Sqrt((xyz1[0]-xyz0[0])*(xyz1[0]-xyz0[0])
+ + (xyz1[1]-xyz0[1])*(xyz1[1]-xyz0[1]));
l2 = 2.0 * TMath::ASin(l2 * crv) / crv;
- l2 = TMath::Sqrt(l2*l2 + (z-oldZ)*(z-oldZ));
+ l2 = TMath::Sqrt(l2*l2 + (xyz1[2]-xyz0[2])*(xyz1[2]-xyz0[2]));
}
AddTimeStep(l2);
}
Double_t alpha = TMath::ATan2(xyz0[1],xyz0[0]);
Rotate(alpha,kTRUE);
GetXYZ(xyz0);
- GetProlongation(x,y,z);
+ if(GetProlongation(x,y,z)<0) return -1;
xyz1[0] = x * TMath::Cos(alpha) + y * TMath::Sin(alpha);
xyz1[1] = x * TMath::Sin(alpha) - y * TMath::Cos(alpha);
xyz1[2] = z;
Double_t alpha = TMath::ATan2(xyz0[1],xyz0[0]);
Rotate(alpha,kTRUE);
GetXYZ(xyz0);
- GetProlongation(r,y,z);
+ if(GetProlongation(r,y,z)<0) return -1;
xyz1[0] = r * TMath::Cos(alpha) + y * TMath::Sin(alpha);
xyz1[1] = r * TMath::Sin(alpha) - y * TMath::Cos(alpha);
xyz1[2] = z;
//_____________________________________________________________________________
void AliTRDtrackV1::Print(Option_t *o) const
{
+ // Print track status
AliInfo(Form("PID [%4.1f %4.1f %4.1f %4.1f %4.1f]", 1.E2*fPID[0], 1.E2*fPID[1], 1.E2*fPID[2], 1.E2*fPID[3], 1.E2*fPID[4]));
AliInfo(Form("Material[%5.2f %5.2f %5.2f]", fBudget[0], fBudget[1], fBudget[2]));
AliInfo(Form("x[%7.2f] t[%7.4f] alpha[%f] mass[%f]", GetX(), GetIntegratedLength(), GetAlpha(), fMass));
AliInfo(Form("Ntr[%1d] NtrPID[%1d] Ncl[%3d] lab[%3d]", GetNumberOfTracklets(), GetNumberOfTrackletsPID(), fN, fLab));
- if(strcmp(o, "a")!=0) return;
printf("|X| = (");
const Double_t *curP = GetParameter();
for (Int_t i = 0; i < 5; i++) printf("%7.2f ", curP[i]);
k=-1; j--;
}
}
+ if(strcmp(o, "a")!=0) return;
for(Int_t ip=0; ip<kNplane; ip++){
if(!fTracklet[ip]) continue;
}
//_______________________________________________________________
-void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *trklt, Int_t index)
+void AliTRDtrackV1::SetTracklet(AliTRDseedV1 *const trklt, Int_t index)
{
//
// Set the tracklets
{
if(plane<0 && plane >= kNplane) return;
fTrackletIndex[plane] = 0xffff;
- fTracklet[plane] = 0x0;
+ fTracklet[plane] = NULL;
}
//
// Update track
//
+ AliDebug(2, Form("Point:\n p=[%6.2f %6.2f]\n V=[%6.2f %6.2f]\n [%6.2f %6.2f]", p[0], p[1], cov[0], cov[1], cov[1], cov[2]));
if(!AliExternalTrackParam::Update(p, cov)) return kFALSE;
// Register info to track
// Update the TRD PID information in the ESD track
//
- Int_t nslices = fReconstructor->IsEightSlices() ? (Int_t)AliTRDpidUtil::kNNslices : (Int_t)AliTRDpidUtil::kLQslices;
- track->SetNumberOfTRDslices(nslices);
-
- Int_t n = 0;
+ Int_t nslices = fkReconstructor->GetRecoParam()->IsEightSlices() ? (Int_t)AliTRDpidUtil::kNNslices : (Int_t)AliTRDpidUtil::kLQslices;
+ // number of tracklets used for PID calculation
+ UChar_t nPID = GetNumberOfTrackletsPID();
+ // number of tracklets attached to the track
+ UChar_t nTrk = GetNumberOfTracklets();
+ // pack the two numbers together and store them in the ESD
+ track->SetTRDntracklets(nPID | (nTrk<<3));
+ // allocate space to store raw PID signals dEdx & momentum
+ track->SetNumberOfTRDslices((nslices+2)*AliTRDgeometry::kNlayer);
+ // store raw signals
+ Float_t p, sp; Double_t spd;
for (Int_t ip = 0; ip < kNplane; ip++) {
if(fTrackletIndex[ip] == 0xffff) continue;
- n++;
- if(!fTracklet[ip]->IsOK()) continue;
- fTracklet[ip]->CookdEdx(nslices);
- Float_t *dedx = fTracklet[ip]->GetdEdx();
+ if(!fTracklet[ip]->HasPID()) continue;
+ const Float_t *dedx = fTracklet[ip]->GetdEdx();
for (Int_t js = 0; js < nslices; js++, dedx++) track->SetTRDslice(*dedx, ip, js);
+ p = fTracklet[ip]->GetMomentum(&sp); spd = sp;
+ track->SetTRDmomentum(p, ip, &spd);
}
-
- UChar_t nPID = GetNumberOfTrackletsPID();
- if(!nPID) track->SetTRDntracklets(n);
- else {
- track->SetTRDpid(fPID);
- n |= (nPID<<3);
- track->SetTRDntracklets(n);
- }
+ // store PID probabilities
+ track->SetTRDpid(fPID);
}