ClassImp(AliTRDtrackerV1::AliTRDLeastSquare)
ClassImp(AliTRDtrackerV1::AliTRDtrackFitterRieman)
-const Float_t AliTRDtrackerV1::fgkMinClustersInTrack = 0.5; //
-const Float_t AliTRDtrackerV1::fgkLabelFraction = 0.8; //
-const Double_t AliTRDtrackerV1::fgkMaxChi2 = 12.0; //
-const Double_t AliTRDtrackerV1::fgkMaxSnp = 0.95; // Maximum local sine of the azimuthal angle
-const Double_t AliTRDtrackerV1::fgkMaxStep = 2.0; // Maximal step size in propagation
+AliTRDtrackerV1::ETRDtrackerV1BetheBloch AliTRDtrackerV1::fgBB = AliTRDtrackerV1::kGeant;
Double_t AliTRDtrackerV1::fgTopologicQA[kNConfigs] = {
0.5112, 0.5112, 0.5112, 0.0786, 0.0786,
0.0786, 0.0786, 0.0579, 0.0579, 0.0474,
};
const Double_t AliTRDtrackerV1::fgkX0[kNPlanes] = {
300.2, 312.8, 325.4, 338.0, 350.6, 363.2};
+// Number of Time Bins/chamber should be also stored independently by the traker
+// (also in AliTRDReconstructor) in oder to be able to run HLT. Fix TODO
Int_t AliTRDtrackerV1::fgNTimeBins = 0;
AliRieman* AliTRDtrackerV1::fgRieman = NULL;
TLinearFitter* AliTRDtrackerV1::fgTiltedRieman = NULL;
TLinearFitter* AliTRDtrackerV1::fgTiltedRiemanConstrained = NULL;
//____________________________________________________________________
-AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec)
+AliTRDtrackerV1::AliTRDtrackerV1(const AliTRDReconstructor *rec)
:AliTracker()
,fkReconstructor(NULL)
,fkRecoParam(NULL)
,fTracks(NULL)
,fTracksESD(NULL)
,fSieveSeeding(0)
+ ,fEventInFile(-1)
{
//
// Default constructor.
Float_t *quality = NULL;
Int_t *index = NULL;
+ fEventInFile = event->GetEventNumberInFile();
nSeeds = event->GetNumberOfTracks();
// Sort tracks according to quality
// (covariance in the yz plane)
if(nSeeds){
quality = new Float_t[nSeeds];
- index = new Int_t[nSeeds];
+ index = new Int_t[4*nSeeds];
for (Int_t iSeed = nSeeds; iSeed--;) {
AliESDtrack *seed = event->GetTrack(iSeed);
Double_t covariance[15];
if ((status & AliESDtrack::kTRDout) != 0) continue;
// Propagate to the entrance in the TRD mother volume
+ track.~AliTRDtrackV1();
new(&track) AliTRDtrackV1(*seed);
- if(AliTRDgeometry::GetXtrdBeg() > (fgkMaxStep + track.GetX()) && !PropagateToX(track, AliTRDgeometry::GetXtrdBeg(), fgkMaxStep)){
+ if(AliTRDgeometry::GetXtrdBeg() > (AliTRDReconstructor::GetMaxStep() + track.GetX()) && !PropagateToX(track, AliTRDgeometry::GetXtrdBeg(), AliTRDReconstructor::GetMaxStep())){
seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
continue;
}
seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
continue;
}
- if(TMath::Abs(track.GetSnp()) > fgkMaxSnp) {
+ if(TMath::Abs(track.GetSnp()) > AliTRDReconstructor::GetMaxSnp()) {
seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
continue;
}
-
nTPCseeds++;
-
+ AliDebug(2, Form("TRD propagate TPC seed[%d] = %d.", iSeed, index[iSeed]));
// store track status at TRD entrance
seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup);
// prepare track and do propagation in the TRD
track.SetReconstructor(fkReconstructor);
track.SetKink(Bool_t(seed->GetKinkIndex(0)));
+ track.SetPrimary(status & AliESDtrack::kTPCin);
expectedClr = FollowBackProlongation(track);
// check if track entered the TRD fiducial volume
if(track.GetTrackIn()){
if (expectedClr<0){
seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
continue;
- }
-
- if(expectedClr){
+ } else {
nFound++;
- // computes PID for track
+ // compute PID
track.CookPID();
+ //compute MC label
+ track.CookLabel(1. - AliTRDReconstructor::GetLabelFraction());
// update calibration references using this track
if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
// save calibration object
track.UpdateESDtrack(seed);
}
- if ((TMath::Abs(track.GetC(track.GetBz()) - p4) / TMath::Abs(p4) < 0.2) ||(track.Pt() > 0.8)) {
-
- // Make backup for back propagation
+ // Make backup for back propagation
+ if ((TMath::Abs(track.GetC(track.GetBz()) - p4) / TMath::Abs(p4) < 0.2) || (track.Pt() > 0.8)) {
Int_t foundClr = track.GetNumberOfClusters();
if (foundClr >= foundMin) {
- track.CookLabel(1. - fgkLabelFraction);
//if(track.GetBackupTrack()) UseClusters(track.GetBackupTrack());
// Sign only gold tracks
xtof = TMath::Sqrt(glob[0]*glob[0]+glob[1]*glob[1]);
}
}
- if(xtof > (fgkMaxStep + track.GetX()) && !PropagateToX(track, xtof, fgkMaxStep)){
+ if(xtof > (AliTRDReconstructor::GetMaxStep() + track.GetX()) && !PropagateToX(track, xtof, AliTRDReconstructor::GetMaxStep())){
seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
continue;
}
seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
continue;
}
- if(TMath::Abs(track.GetSnp()) > fgkMaxSnp){
+ if(TMath::Abs(track.GetSnp()) > AliTRDReconstructor::GetMaxSnp()){
seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
continue;
}
}
// Prolongate to TPC
- if (PropagateToX(track, xTPC, fgkMaxStep)) { // -with update
+ if (PropagateToX(track, xTPC, AliTRDReconstructor::GetMaxStep())) { // -with update
seed->UpdateTrackParams(&track, AliESDtrack::kTRDrefit);
found++;
kUPDATE = kTRUE;
// Prolongate to TPC without update
if(!kUPDATE) {
AliTRDtrackV1 tt(*seed);
- if (PropagateToX(tt, xTPC, fgkMaxStep)) seed->UpdateTrackParams(&tt, AliESDtrack::kTRDbackup);
+ if (PropagateToX(tt, xTPC, AliTRDReconstructor::GetMaxStep())) seed->UpdateTrackParams(&tt, AliESDtrack::kTRDbackup);
}
}
AliInfo(Form("Number of seeds: TRDout[%d]", nseed));
}
Double_t x = tracklet->GetX();//GetX0();
// reject tracklets which are not considered for inward refit
- if(x > t.GetX()+fgkMaxStep) continue;
+ if(x > t.GetX()+AliTRDReconstructor::GetMaxStep()) continue;
// append tracklet to track
t.SetTracklet(tracklet, index);
- if (x < (t.GetX()-fgkMaxStep) && !PropagateToX(t, x+fgkMaxStep, fgkMaxStep)) break;
+ if (x < (t.GetX()-AliTRDReconstructor::GetMaxStep()) && !PropagateToX(t, x+AliTRDReconstructor::GetMaxStep(), AliTRDReconstructor::GetMaxStep())) break;
if (!AdjustSector(&t)) break;
// Start global position
Double_t cov[3]; tracklet->GetCovAt(x, cov);
Double_t p[2] = { tracklet->GetY(), tracklet->GetZ()};
Double_t chi2 = ((AliExternalTrackParam)t).GetPredictedChi2(p, cov);
- if (chi2 < 1e+10 && t.Update(p, cov, chi2)){
+ if (chi2 < 1e+10 && ((AliExternalTrackParam&)t).Update(p, cov)){
+ // Register info to track
+ t.SetNumberOfClusters();
+ t.UpdateChi2(chi2);
nClustersExpected += tracklet->GetN();
}
}
Int_t debugLevel = fkReconstructor->IsDebugStreaming() ? fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) : 0;
TTreeSRedirector *cstreamer = fkReconstructor->IsDebugStreaming() ? fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker) : 0x0;
- Bool_t kStoreIn(kTRUE), //
- kPropagateIn(kTRUE), //
+ Bool_t kStoreIn(kTRUE), // toggel store track params. at TRD entry
kStandAlone(kFALSE), // toggle tracker awarness of stand alone seeding
kUseTRD(fkRecoParam->IsOverPtThreshold(t.Pt()));// use TRD measurment to update Kalman
t.UnsetTracklet(ip);
if(tracklets[ip]->IsOK()) startLayer=ip;
kStandAlone = kTRUE;
+ kUseTRD = kTRUE;
}
AliDebug(4, Form("SA[%c] Start[%d]\n"
" [0]idx[%d] traklet[%p]\n"
// Loop through the TRD layers
TGeoHMatrix *matrix = NULL;
- Double_t x, y, z;
+ Double_t x(0.), y(0.), z(0.);
for (Int_t ily=startLayer, sm=-1, stk=-1, det=-1; ily < AliTRDgeometry::kNlayer; ily++) {
AliDebug(2, Form("Propagate to x[%d] = %7.2f", ily, fR[ily]));
// rough estimate of the entry point
if (!t.GetProlongation(fR[ily], y, z)){
n=-1;
- t.SetStatus(AliTRDtrackV1::kProlongation);
+ t.SetErrStat(AliTRDtrackV1::kProlongation);
AliDebug(4, Form("Failed Rough Prolongation to ly[%d] x[%7.2f] y[%7.2f] z[%7.2f]", ily, fR[ily], y, z));
break;
}
stk = fGeom->GetStack(z, ily);
det = stk>=0 ? AliTRDgeometry::GetDetector(ily, stk, sm) : -1;
matrix = det>=0 ? fGeom->GetClusterMatrix(det) : NULL;
- AliDebug(3, Form("Propagate to det[%3d]", det));
// check if supermodule/chamber is installed
if( !fGeom->GetSMstatus(sm) ||
!matrix ){
AliDebug(4, Form("Missing Geometry ly[%d]. Guess radial position", ily));
// propagate to the default radial position
- if(fR[ily] > (fgkMaxStep + t.GetX()) && !PropagateToX(t, fR[ily], fgkMaxStep)){
+ if(fR[ily] > (AliTRDReconstructor::GetMaxStep() + t.GetX()) && !PropagateToX(t, fR[ily], AliTRDReconstructor::GetMaxStep())){
n=-1;
- t.SetStatus(AliTRDtrackV1::kPropagation);
+ t.SetErrStat(AliTRDtrackV1::kPropagation);
AliDebug(4, "Failed Propagation [Missing Geometry]");
break;
}
if(!AdjustSector(&t)){
n=-1;
- t.SetStatus(AliTRDtrackV1::kAdjustSector);
+ t.SetErrStat(AliTRDtrackV1::kAdjustSector);
AliDebug(4, "Failed Adjust Sector [Missing Geometry]");
break;
}
- if(TMath::Abs(t.GetSnp()) > fgkMaxSnp){
+ if(TMath::Abs(t.GetSnp()) > AliTRDReconstructor::GetMaxSnp()){
n=-1;
- t.SetStatus(AliTRDtrackV1::kSnp);
+ t.SetErrStat(AliTRDtrackV1::kSnp);
AliDebug(4, "Failed Max Snp [Missing Geometry]");
break;
}
- t.SetStatus(AliTRDtrackV1::kGeometry, ily);
+ t.SetErrStat(AliTRDtrackV1::kGeometry, ily);
continue;
}
Double_t loc[] = {AliTRDgeometry::AnodePos()- driftLength, 0., 0.};
Double_t glb[] = {0., 0., 0.};
matrix->LocalToMaster(loc, glb);
+ AliDebug(3, Form("Propagate to det[%3d] x_anode[%7.2f] (%f %f)", det, glb[0]+driftLength, glb[1], glb[2]));
// Propagate to the radial distance of the current layer
- x = glb[0] - fgkMaxStep;
- if(x > (fgkMaxStep + t.GetX()) && !PropagateToX(t, x, fgkMaxStep)){
+ x = glb[0] - AliTRDReconstructor::GetMaxStep();
+ if(x > (AliTRDReconstructor::GetMaxStep() + t.GetX()) && !PropagateToX(t, x, AliTRDReconstructor::GetMaxStep())){
n=-1;
- t.SetStatus(AliTRDtrackV1::kPropagation);
+ t.SetErrStat(AliTRDtrackV1::kPropagation);
AliDebug(4, Form("Failed Initial Propagation to x[%7.2f]", x));
break;
}
if(!AdjustSector(&t)){
n=-1;
- t.SetStatus(AliTRDtrackV1::kAdjustSector);
+ t.SetErrStat(AliTRDtrackV1::kAdjustSector);
AliDebug(4, "Failed Adjust Sector Start");
break;
}
- if(TMath::Abs(t.GetSnp()) > fgkMaxSnp) {
+ if(TMath::Abs(t.GetSnp()) > AliTRDReconstructor::GetMaxSnp()) {
n=-1;
- t.SetStatus(AliTRDtrackV1::kSnp);
- AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), fgkMaxSnp));
+ t.SetErrStat(AliTRDtrackV1::kSnp);
+ AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), AliTRDReconstructor::GetMaxSnp()));
break;
}
Bool_t doRecalculate = kFALSE;
if(doRecalculate){
det = AliTRDgeometry::GetDetector(ily, stk, sm);
if(!(matrix = fGeom->GetClusterMatrix(det))){
- t.SetStatus(AliTRDtrackV1::kGeometry, ily);
+ t.SetErrStat(AliTRDtrackV1::kGeometry, ily);
AliDebug(4, Form("Failed Geometry Matrix ly[%d]", ily));
continue;
}
matrix->LocalToMaster(loc, glb);
- x = glb[0] - fgkMaxStep;
+ x = glb[0] - AliTRDReconstructor::GetMaxStep();
}
// check if track is well inside fiducial volume
- if (!t.GetProlongation(x+fgkMaxStep, y, z)) {
+ if (!t.GetProlongation(x+AliTRDReconstructor::GetMaxStep(), y, z)) {
n=-1;
- t.SetStatus(AliTRDtrackV1::kProlongation);
- AliDebug(4, Form("Failed Prolongation to x[%7.2f] y[%7.2f] z[%7.2f]", x+fgkMaxStep, y, z));
+ t.SetErrStat(AliTRDtrackV1::kProlongation);
+ AliDebug(4, Form("Failed Prolongation to x[%7.2f] y[%7.2f] z[%7.2f]", x+AliTRDReconstructor::GetMaxStep(), y, z));
break;
}
if(fGeom->IsOnBoundary(det, y, z, .5)){
- t.SetStatus(AliTRDtrackV1::kBoundary, ily);
+ t.SetErrStat(AliTRDtrackV1::kBoundary, ily);
AliDebug(4, "Failed Track on Boundary");
continue;
}
- // mark track as entering the FIDUCIAL volume of TRD
- if(kStoreIn){
- t.SetTrackIn();
- kStoreIn = kFALSE;
- }
ptrTracklet = tracklets[ily];
if(!ptrTracklet){ // BUILD TRACKLET
AliDebug(3, Form("Building tracklet det[%d]", det));
// check data in supermodule
if(!fTrSec[sm].GetNChambers()){
- t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+ t.SetErrStat(AliTRDtrackV1::kNoClusters, ily);
AliDebug(4, "Failed NoClusters");
continue;
}
if(fTrSec[sm].GetX(ily) < 1.){
- t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+ t.SetErrStat(AliTRDtrackV1::kNoClusters, ily);
AliDebug(4, "Failed NoX");
continue;
}
// check data in chamber
if(!(chamber = fTrSec[sm].GetChamber(stk, ily))){
- t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+ t.SetErrStat(AliTRDtrackV1::kNoClusters, ily);
AliDebug(4, "Failed No Detector");
continue;
}
if(chamber->GetNClusters() < fgNTimeBins*fkRecoParam ->GetFindableClusters()){
- t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+ t.SetErrStat(AliTRDtrackV1::kNoClusters, ily);
AliDebug(4, "Failed Not Enough Clusters in Detector");
continue;
}
// build tracklet
+ tracklet.~AliTRDseedV1();
ptrTracklet = new(&tracklet) AliTRDseedV1(det);
ptrTracklet->SetReconstructor(fkReconstructor);
ptrTracklet->SetKink(t.IsKink());
+ ptrTracklet->SetPrimary(t.IsPrimary());
ptrTracklet->SetPadPlane(fGeom->GetPadPlane(ily, stk));
ptrTracklet->SetX0(glb[0]+driftLength);
- if(!tracklet.Init(&t)){
+ if(!ptrTracklet->Init(&t)){
n=-1;
- t.SetStatus(AliTRDtrackV1::kTrackletInit);
+ t.SetErrStat(AliTRDtrackV1::kTrackletInit);
AliDebug(4, "Failed Tracklet Init");
break;
}
- if(!tracklet.AttachClusters(chamber, kTRUE)){
- t.SetStatus(AliTRDtrackV1::kNoAttach, ily);
+ // Select attachment base on track to B field sign not only track charge which is buggy
+ // mark kFALSE same sign tracks and kTRUE opposite sign tracks
+ // A.Bercuci 3.11.2011
+ Float_t prod(t.GetBz()*t.Charge());
+ if(!ptrTracklet->AttachClusters(chamber, kTRUE, prod<0.?kTRUE:kFALSE, fEventInFile)){
+ t.SetErrStat(AliTRDtrackV1::kNoAttach, ily);
if(debugLevel>3){
AliTRDseedV1 trackletCp(*ptrTracklet);
UChar_t status(t.GetStatusTRD(ily));
- (*cstreamer) << "FollowBackProlongation2"
+ (*cstreamer) << "FollowBackProlongation4"
<<"status=" << status
<<"tracklet.=" << &trackletCp
<< "\n";
AliDebug(4, "Failed Attach Clusters");
continue;
}
- AliDebug(3, Form("Number of Clusters in Tracklet: %d", tracklet.GetN()));
- if(tracklet.GetN() < fgNTimeBins*fkRecoParam ->GetFindableClusters()){
- t.SetStatus(AliTRDtrackV1::kNoClustersTracklet, ily);
+ AliDebug(3, Form("Number of Clusters in Tracklet: %d", ptrTracklet->GetN()));
+ if(ptrTracklet->GetN() < fgNTimeBins*fkRecoParam->GetFindableClusters()){
+ t.SetErrStat(AliTRDtrackV1::kNoClustersTracklet, ily);
if(debugLevel>3){
AliTRDseedV1 trackletCp(*ptrTracklet);
UChar_t status(t.GetStatusTRD(ily));
- (*cstreamer) << "FollowBackProlongation2"
+ (*cstreamer) << "FollowBackProlongation4"
<<"status=" << status
<<"tracklet.=" << &trackletCp
<< "\n";
} else AliDebug(2, Form("Use external tracklet ly[%d]", ily));
// propagate track to the radial position of the tracklet
- // fit tracklet no tilt correction
- if(!ptrTracklet->Fit(kFALSE)){
- t.SetStatus(AliTRDtrackV1::kNoFit, ily);
+ // fit tracklet
+ // tilt correction options
+ // 0 : no correction
+ // 2 : pseudo tilt correction
+ if(!ptrTracklet->FitRobust(t.Charge()>0?kTRUE:kFALSE)){
+ t.SetErrStat(AliTRDtrackV1::kNoFit, ily);
AliDebug(4, "Failed Tracklet Fit");
continue;
}
x = ptrTracklet->GetX(); //GetX0();
- if(x > (fgkMaxStep + t.GetX()) && !PropagateToX(t, x, fgkMaxStep)) {
+ if(x > (AliTRDReconstructor::GetMaxStep() + t.GetX()) && !PropagateToX(t, x, AliTRDReconstructor::GetMaxStep())) {
n=-1;
- t.SetStatus(AliTRDtrackV1::kPropagation);
+ t.SetErrStat(AliTRDtrackV1::kPropagation);
AliDebug(4, Form("Failed Propagation to Tracklet x[%7.2f]", x));
break;
}
if(!AdjustSector(&t)) {
n=-1;
- t.SetStatus(AliTRDtrackV1::kAdjustSector);
+ t.SetErrStat(AliTRDtrackV1::kAdjustSector);
AliDebug(4, "Failed Adjust Sector");
break;
}
- if(TMath::Abs(t.GetSnp()) > fgkMaxSnp) {
+ if(TMath::Abs(t.GetSnp()) > AliTRDReconstructor::GetMaxSnp()) {
n=-1;
- t.SetStatus(AliTRDtrackV1::kSnp);
- AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), fgkMaxSnp));
+ t.SetErrStat(AliTRDtrackV1::kSnp);
+ AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), AliTRDReconstructor::GetMaxSnp()));
break;
}
- if(kPropagateIn){
- t.SetTrackIn();
- kPropagateIn = kFALSE;
- }
Double_t cov[3]; ptrTracklet->GetCovAt(x, cov);
Double_t p[2] = { ptrTracklet->GetY(), ptrTracklet->GetZ()};
Double_t chi2 = ((AliExternalTrackParam)t).GetPredictedChi2(p, cov);
// update Kalman with the TRD measurement
if(chi2>1e+10){ // TODO
- t.SetStatus(AliTRDtrackV1::kChi2, ily);
+ t.SetErrStat(AliTRDtrackV1::kChi2, ily);
if(debugLevel > 2){
UChar_t status(t.GetStatusTRD());
AliTRDseedV1 trackletCp(*ptrTracklet);
AliTRDtrackV1 trackCp(t);
trackCp.SetOwner();
- (*cstreamer) << "FollowBackProlongation1"
+ (*cstreamer) << "FollowBackProlongation3"
<< "status=" << status
<< "tracklet.=" << &trackletCp
<< "track.=" << &trackCp
AliDebug(4, Form("Failed Chi2[%f]", chi2));
continue;
}
- if(!t.Update(p, cov, chi2, kUseTRD)) {
- n=-1;
- t.SetStatus(AliTRDtrackV1::kUpdate);
- if(debugLevel > 2){
- UChar_t status(t.GetStatusTRD());
- AliTRDseedV1 trackletCp(*ptrTracklet);
- AliTRDtrackV1 trackCp(t);
- trackCp.SetOwner();
- (*cstreamer) << "FollowBackProlongation1"
- << "status=" << status
- << "tracklet.=" << &trackletCp
- << "track.=" << &trackCp
- << "\n";
+ // mark track as entering the FIDUCIAL volume of TRD
+ if(kStoreIn){
+ t.SetTrackIn();
+ kStoreIn = kFALSE;
+ }
+ if(kUseTRD){
+ if(!((AliExternalTrackParam&)t).Update(p, cov)) {
+ n=-1;
+ t.SetErrStat(AliTRDtrackV1::kUpdate);
+ if(debugLevel > 2){
+ UChar_t status(t.GetStatusTRD());
+ AliTRDseedV1 trackletCp(*ptrTracklet);
+ AliTRDtrackV1 trackCp(t);
+ trackCp.SetOwner();
+ (*cstreamer) << "FollowBackProlongation3"
+ << "status=" << status
+ << "tracklet.=" << &trackletCp
+ << "track.=" << &trackCp
+ << "\n";
+ }
+ AliDebug(4, Form("Failed Track Update @ y[%7.2f] z[%7.2f] s2y[%f] s2z[%f] covyz[%f]", p[0], p[1], cov[0], cov[2], cov[1]));
+ break;
}
- AliDebug(4, Form("Failed Track Update @ y[%7.2f] z[%7.2f] s2y[%f] s2z[%f] covyz[%f]", p[0], p[1], cov[0], cov[2], cov[1]));
- break;
}
if(!kStandAlone) ptrTracklet->UseClusters();
// fill residuals ?!
AliTracker::FillResiduals(&t, p, cov, ptrTracklet->GetVolumeId());
- // load tracklet to the tracker
- ptrTracklet->Update(&t);
+ // register tracklet with the tracker and track
+ // Save inside the tracklet the track parameters BEFORE track update.
+ // Commented out their overwriting AFTER track update
+ // A.Bercuci 3.11.2011
+ //ptrTracklet->Update(&t);
ptrTracklet = SetTracklet(ptrTracklet);
Int_t index(fTracklets->GetEntriesFast()-1);
t.SetTracklet(ptrTracklet, index);
+ // Register info to track
+ t.SetNumberOfClusters();
+ t.UpdateChi2(chi2);
+
n += ptrTracklet->GetN();
AliDebug(2, Form("Setting Tracklet[%d] @ Idx[%d]", ily, index));
//printf("clusters[%d] chi2[%f] x[%f] status[%d ", n, t.GetChi2(), t.GetX(), t.GetStatusTRD());
//for(int i=0; i<6; i++) printf("%d ", t.GetStatusTRD(i)); printf("]\n");
- if(debugLevel > 1){
- Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
+ if(n && debugLevel > 1){
+ //Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
AliTRDtrackV1 track(t);
track.SetOwner();
- (*cstreamer) << "FollowBackProlongation0"
- << "EventNumber=" << eventNumber
- << "ncl=" << n
+ (*cstreamer) << "FollowBackProlongation2"
+ << "EventNumber=" << fEventInFile
<< "track.=" << &track
<< "\n";
}
if(!tracklets[ilr].IsOK()) continue;
for(Int_t itb = 0; itb < AliTRDseedV1::kNclusters; itb++){
if(!tracklets[ilr].IsUsable(itb)) continue;
- cl = tracklets[ilr].GetClusters(itb);
+ if(!(cl = tracklets[ilr].GetClusters(itb))) continue;
if(!cl->IsInChamber()) continue;
- if(cl->GetSigmaY2()<1.e-6 || cl->GetSigmaZ2()<1.e-6){
- if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>1) printf("D-AliTRDtrackerV1::FitTiltedRiemanConstraint: Cluster error parameterization missing. This should appear only in HLT tests.");
- continue;
- }
x = cl->GetX();
y = cl->GetY();
z = cl->GetZ();
Double_t b = fitter->GetParameter(1);
Double_t curvature = a/TMath::Sqrt(b*b + 1);
- Float_t chi2track = fitter->GetChisquare()/Double_t(nPoints);
+ Float_t chi2track = 0.0;
+ if (nPoints > 0) {
+ chi2track = fitter->GetChisquare()/Double_t(nPoints);
+ }
for(Int_t ip = 0; ip < AliTRDtrackerV1::kNPlanes; ip++)
tracklets[ip].SetC(curvature, 1);
x = cl->GetX();
y = cl->GetY();
z = cl->GetZ();
- if(cl->GetSigmaY2()<1.e-6 || cl->GetSigmaZ2()<1.e-6){
- if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>1) printf("D-AliTRDtrackerV1::FitTiltedRieman: Cluster error parameterization missing. This should appear only in HLT tests.");
- tracklets[ipl].Print("a");
- continue;
- }
dx = x - xref;
// Transformation
t = 1./(x*x + y*y);
nPoints++;
}
}
- fitter->Eval();
+ if (fitter->Eval()) return 1.e10;
zfitter.Eval();
Double_t offset = fitter->GetParameter(3);
//if(points) printf("First marker point @ x[%d] = %f\n", ip, points[ip].GetX());
- AliTRDseedV1 tracklet, *ptrTracklet = NULL;
+ AliTRDseedV1 tracklet;
+ AliTRDseedV1 *ptrTracklet = NULL;
//Loop through the TRD planes
for (Int_t jplane = 0; jplane < kNPlanes; jplane++) {
while(ip < np){
//don't do anything if next marker is after next update point.
- if((up?-1:1) * (points[ip].GetX() - x) - fgkMaxStep < 0) break;
- if(((up?-1:1) * (points[ip].GetX() - track->GetX()) < 0) && !PropagateToX(*track, points[ip].GetX(), fgkMaxStep)) return -1.;
+ if((up?-1:1) * (points[ip].GetX() - x) - AliTRDReconstructor::GetMaxStep() < 0) break;
+ if(((up?-1:1) * (points[ip].GetX() - track->GetX()) < 0) && !PropagateToX(*track, points[ip].GetX(), AliTRDReconstructor::GetMaxStep())) return -1.;
Double_t xyz[3]; // should also get the covariance
track->GetXYZ(xyz);
// printf("plane[%d] tracklet[%p] x[%f]\n", iplane, ptrTracklet, x);
// Propagate closer to the next update point
- if(((up?-1:1) * (x - track->GetX()) + fgkMaxStep < 0) && !PropagateToX(*track, x + (up?-1:1)*fgkMaxStep, fgkMaxStep)) return -1.;
+ if(((up?-1:1) * (x - track->GetX()) + AliTRDReconstructor::GetMaxStep() < 0) && !PropagateToX(*track, x + (up?-1:1)*AliTRDReconstructor::GetMaxStep(), AliTRDReconstructor::GetMaxStep())) return -1.;
if(!AdjustSector(track)) return -1;
- if(TMath::Abs(track->GetSnp()) > fgkMaxSnp) return -1;
+ if(TMath::Abs(track->GetSnp()) > AliTRDReconstructor::GetMaxSnp()) return -1;
//load tracklet to the tracker and the track
/* Int_t index;
Double_t cov[3]; ptrTracklet->GetCovAt(x, cov);
Double_t p[2] = { ptrTracklet->GetY(), ptrTracklet->GetZ()};
Double_t chi2 = ((AliExternalTrackParam*)track)->GetPredictedChi2(p, cov);
- if(chi2<1e+10) track->Update(p, cov, chi2);
+ if(chi2<1e+10) ((AliExternalTrackParam*)track)->Update(p, cov);
if(!up) continue;
//Reset material budget if 2 consecutive gold
// extrapolation
while(ip < np){
- if(((up?-1:1) * (points[ip].GetX() - track->GetX()) < 0) && !PropagateToX(*track, points[ip].GetX(), fgkMaxStep)) return -1.;
+ if(((up?-1:1) * (points[ip].GetX() - track->GetX()) < 0) && !PropagateToX(*track, points[ip].GetX(), AliTRDReconstructor::GetMaxStep())) return -1.;
Double_t xyz[3]; // should also get the covariance
track->GetXYZ(xyz);
}
//_________________________________________________________________________
-Float_t AliTRDtrackerV1::CalculateChi2Z(AliTRDseedV1 *tracklets, Double_t offset, Double_t slope, Double_t xref)
+Float_t AliTRDtrackerV1::CalculateChi2Z(const AliTRDseedV1 *tracklets, Double_t offset, Double_t slope, Double_t xref)
{
//
// Calculates the chi2-value of the track in z-Direction including tilting pad correction.
// Returns 1 if track reaches the plane, and 0 otherwise
//
- const Double_t kEpsilon = 0.00001;
-
// Current track X-position
- Double_t xpos = t.GetX();
+ Double_t xpos = t.GetX()/*,
+ mass = t.GetMass()*/;
// Direction: inward or outward
Double_t dir = (xpos < xToGo) ? 1.0 : -1.0;
- while (((xToGo - xpos) * dir) > kEpsilon) {
-
+ while (((xToGo - xpos) * dir) > AliTRDReconstructor::GetEpsilon()) {
+// printf("to go %f\n", (xToGo - xpos) * dir);
Double_t xyz0[3];
Double_t xyz1[3];
Double_t param[7];
// Calculate the mean material budget between start and
// end point of this prolongation step
if(AliTracker::MeanMaterialBudget(xyz0, xyz1, param)<=0.) return 0;
-
+
// Propagate the track to the X-position after the next step
if (!t.PropagateTo(x, param[1], param[0]*param[4])) return 0;
+/* // Correct for mean material budget
+ Double_t dEdx(0.),
+ bg(t.GetP()/mass);
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>=3){
+ const char *pn[] = {"rho", "x/X0", "<A>", "<Z>", "L", "<Z/A>", "Nb"};
+ printf("D-AliTRDtrackerV1::PropagateTo(): x[%6.2f] bg[%6.2f]\n", xpos, bg);
+ printf(" param :: %s[%e] %s[%e] %s[%e] %s[%e] %s[%e] %s[%e] %s[%e]\n"
+ , pn[0], param[0]
+ , pn[1], param[1]
+ , pn[2], param[2]
+ , pn[3], param[3]
+ , pn[4], param[4]
+ , pn[5], param[5]
+ , pn[6], param[6]);
+ }
+ switch(fgBB){
+ case kSolid:
+ dEdx = AliExternalTrackParam::BetheBlochSolid(bg);
+ break;
+ case kGas:
+ dEdx = AliExternalTrackParam::BetheBlochGas(bg);
+ break;
+ case kGeant:
+ { // mean exitation energy (GeV)
+ Double_t mee = ((param[3] < 13.) ? (12. * param[3] + 7.) : (9.76 * param[3] + 58.8 * TMath::Power(param[3],-0.19))) * 1.e-9;
+ Double_t mZA = param[5]>1.e-5?param[5]:(param[3]/param[2]);
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>=3) printf("D-AliTRDtrackerV1::PropagateTo(): Mee[%e] <Z/A>[%e]\n", mee, mZA);
+ // protect against failed calculation of rho in MeanMaterialBudget()
+ dEdx = AliExternalTrackParam::BetheBlochGeant(bg, param[0]>1.e-6?param[0]:2.33, 0.2, 3., mee, mZA);
+ }
+ break;
+ }
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>=2) printf("D-AliTRDtrackerV1::PropagateTo(): dEdx(bg=%e, m=%e)= %e[GeV/cm]\n", bg, mass, dEdx);
+ if (!t.CorrectForMeanMaterialdEdx(param[1], dir*param[0]*param[4], mass, dEdx)) return 0;
+*/
// Rotate the track if necessary
- AdjustSector(&t);
+ if(!AdjustSector(&t)) return 0;
// New track X-position
xpos = t.GetX();
}
-
//_____________________________________________________________________________
-Int_t AliTRDtrackerV1::ReadClusters(TClonesArray* &array, TTree *clusterTree) const
+Bool_t AliTRDtrackerV1::ReadClusters(TTree *clusterTree)
{
//
// Reads AliTRDclusters from the file.
TBranch *branch = clusterTree->GetBranch("TRDcluster");
if (!branch) {
AliError("Can't get the branch !");
- return 1;
+ return kFALSE;
}
branch->SetAddress(&clusterArray);
if(!fClusters){
Float_t nclusters = fkRecoParam->GetNClusters();
if(fkReconstructor->IsHLT()) nclusters /= AliTRDgeometry::kNsector;
- array = new TClonesArray("AliTRDcluster", Int_t(nclusters));
- array->SetOwner(kTRUE);
+ fClusters = new TClonesArray("AliTRDcluster", Int_t(nclusters));
+ fClusters->SetOwner(kTRUE);
}
// Loop through all entries in the tree
new((*fClusters)[ncl++]) AliTRDcluster(*c);
delete (clusterArray->RemoveAt(iCluster));
}
-
}
delete clusterArray;
- return 0;
+ return kTRUE;
}
//_____________________________________________________________________________
if(!fkReconstructor->IsWritingClusters()){
fClusters = AliTRDReconstructor::GetClusters();
} else {
- if (ReadClusters(fClusters, cTree)) {
+ if(!ReadClusters(cTree)) {
AliError("Problem with reading the clusters !");
return 1;
}
Int_t stack = fGeom->GetStack(detector);
Int_t layer = fGeom->GetLayer(detector);
- fTrSec[sector].GetChamber(stack, layer, kTRUE)->InsertCluster(c, ncl, fkReconstructor->IsHLT());
+ fTrSec[sector].GetChamber(stack, layer, kTRUE)->InsertCluster(c, ncl);
}
for(int isector =0; isector<AliTRDgeometry::kNsector; isector++){
//____________________________________________________________________
-AliTRDseedV1* AliTRDtrackerV1::GetTracklet(AliTRDtrackV1 *const track, Int_t p, Int_t &idx)
+AliTRDseedV1* AliTRDtrackerV1::GetTracklet(const AliTRDtrackV1 *const track, Int_t p, Int_t &idx)
{
// Find tracklet for TRD track <track>
// Parameters
do{
// Loop over seeding configurations
ntracks = 0; ntracks1 = 0;
- for (Int_t iconf = 0; iconf<3; iconf++) {
+ for (Int_t iconf = 0; iconf<fkRecoParam->GetNumberOfSeedConfigs(); iconf++) {
pars[0] = configs[iconf];
pars[1] = ntracks;
pars[2] = istack;
if(!ntracks) break;
// Sort the seeds according to their quality
- Int_t sort[kMaxTracksStack];
+ Int_t sort[kMaxTracksStack+1];
TMath::Sort(ntracks, fTrackQuality, sort, kTRUE);
if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1") > 2){
AliDebug(3, "Track candidates classification:");
break;
case 1: // select shorter primary tracks, good quality
- if(findable<4){skip = kTRUE; break;}
+ //if(findable<4){skip = kTRUE; break;}
if(nlayers < findable){skip = kTRUE; break;}
if(TMath::Log(1.E-9+fTrackQuality[trackIndex]) < -4.){skip = kTRUE; break;}
break;
}
TMath::Sort((Int_t)kNConfigs, tconfig, configs, kTRUE);
- // AliInfo(Form("q[%d] = %f", configs[0], tconfig[configs[0]]));
+ // AliInfo(Form("q[%d] = %f", configs[0], tconfig[configs[0]]));
// AliInfo(Form("q[%d] = %f", configs[1], tconfig[configs[1]]));
// AliInfo(Form("q[%d] = %f", configs[2], tconfig[configs[2]]));
for(int iLayer=0; iLayer<kNPlanes; iLayer++,cIter++){
if(!(*cIter)) continue;
if(!(matrix = fGeom->GetClusterMatrix((*cIter)->GetDetector()))){
- continue;
x0[iLayer] = fgkX0[iLayer];
+ continue;
}
matrix->LocalToMaster(loc, glb);
x0[iLayer] = glb[0];
if(!cseed[jLayer].AttachClusters(chamber, kTRUE)) continue;
cseed[jLayer].Fit();
}
- FitTiltedRiemanConstraint(&cseed[0], GetZ());
+ //FitTiltedRiemanConstraint(&cseed[0], GetZ());
fTrackQuality[ntracks] = 1.; // dummy value
ntracks++;
if(ntracks == kMaxTracksStack) return ntracks;
chi2Vals[0] = FitTiltedRieman(&cseed[0], kTRUE);
for(int iLayer=0; iLayer<kNSeedPlanes; iLayer++){
Int_t jLayer = planes[iLayer];
- cseed[jLayer].Fit(kTRUE);
+ cseed[jLayer].Fit(1);
}
Double_t like = CookLikelihood(&cseed[0], planes); // to be checked
if ((jLayer == 5) && !(cseed[4].IsOK())) continue;
AliTRDseedV1 pseed = cseed[jLayer];
if(!pseed.AttachClusters(chamber, kTRUE)) continue;
- pseed.Fit(kTRUE);
+ pseed.Fit(1);
cseed[jLayer] = pseed;
chi2Vals[0] = FitTiltedRieman(cseed, kTRUE);
- cseed[jLayer].Fit(kTRUE);
+ cseed[jLayer].Fit(1);
elayers++;
}
// offline case perform a full Kalman filter on the already found tracklets (see AliTRDtrackerV1::FollowBackProlongation()
// for details). Do also MC label calculation and PID if propagation successfully.
-
+ if(fkReconstructor->IsHLT()) FitTiltedRiemanConstraint(tracklet, 0);
Double_t alpha = AliTRDgeometry::GetAlpha();
Double_t shift = AliTRDgeometry::GetAlpha()/2.0;
ptrTrack->CookPID();
// update calibration references using this track
AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
- if (!calibra){
- AliInfo("Could not get Calibra instance\n");
- if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(ptrTrack);
+ if(!calibra){
+ AliInfo("Could not get Calibra instance.");
+ } else if(calibra->GetHisto2d()){
+ calibra->UpdateHistogramsV1(ptrTrack);
}
return ptrTrack;
}
AliTRDseedV1 bseed[AliTRDgeometry::kNlayer];
Float_t quality(1.e3),
- lQuality[] = {1.e3, 1.e3, 1.e3, 1.e3, 1.e3, 1.e3};
+ lQuality[AliTRDgeometry::kNlayer] = {1.e3, 1.e3, 1.e3, 1.e3, 1.e3, 1.e3};
Int_t rLayers(0);
for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;){
bseed[jLayer] = cseed[jLayer];
lQuality[jLayer] = bseed[jLayer].GetQuality(kTRUE);
quality += lQuality[jLayer];
}
- quality /= rLayers;
+ if (rLayers > 0) {
+ quality /= rLayers;
+ }
AliDebug(2, Form("Start N[%d] Q[%f] chi2[%f]", rLayers, quality, chi2));
for (Int_t iter = 0; iter < 4; iter++) {
// Try better cluster set
Int_t nLayers(0); Float_t qualitynew(0.);
- Int_t indexes[6];
+ Int_t indexes[4*AliTRDgeometry::kNlayer];
TMath::Sort(Int_t(AliTRDgeometry::kNlayer), lQuality, indexes, kFALSE);
for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) {
Int_t bLayer = indexes[jLayer];
bseed[bLayer].Reset("c");
if(!(chamber = stack[bLayer])) continue;
if(!bseed[bLayer].AttachClusters(chamber, kTRUE)) continue;
- bseed[bLayer].Fit(kTRUE);
+ bseed[bLayer].Fit(1);
if(!bseed[bLayer].IsOK()) continue;
nLayers++;
lQuality[jLayer] = bseed[jLayer].GetQuality(kTRUE);
//____________________________________________________________________
void AliTRDtrackerV1::UnsetTrackletsTrack(const AliTRDtrackV1 * const track)
{
+// Remove tracklets from tracker list attached to "track"
Int_t idx(-1);
for(Int_t il(0); il<kNPlanes; il++){
if((idx = track->GetTrackletIndex(il)) < 0) continue;
//
Double_t det = fSums[0] * fSums[4] - fSums[1] *fSums[1];
- if(det==0) return kFALSE;
+ if(TMath::Abs(det)<1.e-30) return kFALSE;
// for(Int_t isum = 0; isum < 5; isum++)
// printf("fSums[%d] = %f\n", isum, fSums[isum]);
}
//_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDtrackFitterRieman::UpdateFitters(AliTRDseedV1 * const tracklet){
+void AliTRDtrackerV1::AliTRDtrackFitterRieman::UpdateFitters(const AliTRDseedV1 * const tracklet){
//
// Does the transformations and updates the fitters
// The following transformation is applied