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)
,fGeom(NULL)
,fClusters(NULL)
,fTracklets(NULL)
,fTracks(NULL)
,fTracksESD(NULL)
,fSieveSeeding(0)
+ ,fEventInFile(-1)
{
//
// Default constructor.
// See AliTRDtrackerV1::Clusters2TracksSM() for details.
//
- if(!fkReconstructor->GetRecoParam() ){
+ if(!fkRecoParam){
AliError("Reconstruction configuration not initialized. Call first AliTRDReconstructor::SetRecoParam().");
return 0;
}
}
AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance(); // Calibration monitor
if (!calibra) AliInfo("Could not get Calibra instance");
- if(!fgNTimeBins) CookNTimeBins();
+ if (!fgNTimeBins) fgNTimeBins = fkReconstructor->GetNTimeBins();
// Define scalers
- Int_t nFound = 0, // number of tracks found
- nSeeds = 0, // total number of ESD seeds
- nTRDseeds= 0, // number of seeds in the TRD acceptance
- nTPCseeds= 0; // number of TPC seeds
+ const Int_t nSeeders(2);
+ Int_t nFound[nSeeders] = {0}, // number of tracks found
+ nBacked = 0, // number of tracks backed up for refit
+ nSeeds = 0, // total number of ESD seeds
+ nTRDseeds = 0, // number of seeds in the TRD acceptance
+ nSeeder[nSeeders]= {0}, // number of ITS/TPC potential seeds
+ nGoodSeeds[nSeeders]= {0}; // number of ITS/TPC found seeds
Float_t foundMin = 20.0;
-
- Float_t *quality = NULL;
- Int_t *index = NULL;
+ const Char_t *seeder[] = {"ITS", "TPC"};
+ Float_t *quality[nSeeders] = {0};
+ Int_t *index[nSeeders] = {0},
+ *idxESD[nSeeders] = {0}; // esd index of track
+ 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];
- for (Int_t iSeed = nSeeds; iSeed--;) {
+ // first check TPC seeds
+ quality[1] = new Float_t[nSeeds]; memset(quality[1], 0, nSeeds*sizeof(Float_t));
+ idxESD[1] = new Int_t[nSeeds];
+ for (Int_t iSeed(nSeeds); iSeed--;) {
+ AliESDtrack *seed = event->GetTrack(iSeed);
+ if(!(seed->GetStatus()&AliESDtrack::kTPCout)) continue;
+ Double_t covariance[15];
+ seed->GetExternalCovariance(covariance);
+ idxESD[1][nSeeder[1]] = iSeed;
+ quality[1][nSeeder[1]] = covariance[0] + covariance[2];
+ nSeeder[1]++;
+ }
+ index[1] = new Int_t[4*nSeeder[1]];
+ TMath::Sort(nSeeder[1], quality[1], index[1], kFALSE);
+ // second check rest of tracks for ITS seeds
+ quality[0] = new Float_t[nSeeds]; memset(quality[0], 0, nSeeds*sizeof(Float_t));
+ idxESD[0] = new Int_t[nSeeds];
+ for (Int_t iSeed(nSeeds); iSeed--;) {
AliESDtrack *seed = event->GetTrack(iSeed);
+ if((seed->GetStatus()&AliESDtrack::kTPCout)) continue;
Double_t covariance[15];
seed->GetExternalCovariance(covariance);
- quality[iSeed] = covariance[0] + covariance[2];
+ idxESD[0][nSeeder[0]] = iSeed;
+ quality[0][nSeeder[0]] = covariance[0] + covariance[2];
+ nSeeder[0]++;
}
- TMath::Sort(nSeeds, quality, index,kFALSE);
+ index[0] = new Int_t[4*nSeeder[0]];
+ TMath::Sort(nSeeder[0], quality[0], index[0], kFALSE);
}
-
+
// Propagate all seeds
Int_t expectedClr;
AliTRDtrackV1 track;
- for (Int_t iSeed = 0; iSeed < nSeeds; iSeed++) {
-
- // Get the seeds in sorted sequence
- AliESDtrack *seed = event->GetTrack(index[iSeed]);
- Float_t p4 = seed->GetC(seed->GetBz());
-
- // Check the seed status
- ULong_t status = seed->GetStatus();
- if ((status & AliESDtrack::kTPCout) == 0) continue;
- if ((status & AliESDtrack::kTRDout) != 0) continue;
-
- // Propagate to the entrance in the TRD mother volume
- new(&track) AliTRDtrackV1(*seed);
- if(AliTRDgeometry::GetXtrdBeg() > (fgkMaxStep + track.GetX()) && !PropagateToX(track, AliTRDgeometry::GetXtrdBeg(), fgkMaxStep)){
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
- continue;
- }
- if(!AdjustSector(&track)){
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
- continue;
- }
- if(TMath::Abs(track.GetSnp()) > fgkMaxSnp) {
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
- continue;
- }
-
- nTPCseeds++;
-
- // store track status at TRD entrance
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup);
+ for(Int_t iSeeder(nSeeders); iSeeder--;){
+ for (Int_t iSeed = 0; iSeed < nSeeder[iSeeder]; iSeed++) {
+ Int_t currentIndexESD = idxESD[iSeeder][index[iSeeder][iSeed]];
+ // Get the seeds in sorted sequence
+ AliESDtrack *seed = event->GetTrack(currentIndexESD);
+ Float_t p4 = seed->GetC(seed->GetBz());
+
+ // Check the seed status
+ ULong_t status(seed->GetStatus()); Bool_t kTPC(kTRUE);
+ if ((status & AliESDtrack::kTRDout) != 0) continue;
+ if (status & AliESDtrack::kTPCout){
+ AliDebug(2, Form("Found TPC seed @ idx[%4d] Sxy=%f[cm].", currentIndexESD, TMath::Sqrt(quality[iSeeder][index[iSeeder][iSeed]])));
+ // set steering parameters for TPC
+ //fkRecoParam->SetTrackParam(kTPC);
+ } else {
+ if (status & AliESDtrack::kITSout){
+ // rotate
+ Float_t globalToTracking = AliTRDgeometry::GetAlpha()*(Int_t(seed->GetAlpha()/AliTRDgeometry::GetAlpha()) + (seed->GetAlpha()>0. ? 0.5 : -0.5));
+ AliDebug(2, Form("Found ITS seed @ idx[%4d] Sxy=%f[cm] alpha=%7.2f[deg] g2T=%7.2f[deg]", currentIndexESD, TMath::Sqrt(quality[iSeeder][index[iSeeder][iSeed]]), seed->GetAlpha()*TMath::RadToDeg(), globalToTracking*TMath::RadToDeg()));
+ if(!seed->Rotate(globalToTracking)){
+ AliDebug(1, Form("ITS seed @ idx[%4d] failed rotation of alpha=%7.2f[deg] g2T=%7.2f[deg].", currentIndexESD, seed->GetAlpha()*TMath::RadToDeg(), globalToTracking*TMath::RadToDeg()));
+ continue;
+ }
+ kTPC=kFALSE;
+ // set steering parameters for ITS
+ //fkRecoParam->SetTrackParam(kITS);
+ } else {
+ AliDebug(1, Form("Bad seed[%4d] ITSin[%c] ITSout[%c] TPCin[%c] TPCout[%c].", currentIndexESD,
+ (status&AliESDtrack::kITSin)?'y':'n', (status&AliESDtrack::kITSout)?'y':'n', (status&AliESDtrack::kTPCin)?'y':'n', (status&AliESDtrack::kTPCout)?'y':'n'));
+ continue;
+ }
+ }
- // prepare track and do propagation in the TRD
- track.SetReconstructor(fkReconstructor);
- track.SetKink(Bool_t(seed->GetKinkIndex(0)));
- expectedClr = FollowBackProlongation(track);
- // check if track entered the TRD fiducial volume
- if(track.GetTrackLow()){
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDin);
- nTRDseeds++;
- }
- // check if track was stopped in the TRD
- if (expectedClr<0){
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
- continue;
- }
+ // Propagate to the entrance in the TRD mother volume
+ track.~AliTRDtrackV1();
+ new(&track) AliTRDtrackV1(*seed);
+ if(AliTRDgeometry::GetXtrdBeg() > (AliTRDReconstructor::GetMaxStep() + track.GetX()) && !PropagateToX(track, AliTRDgeometry::GetXtrdBeg(), AliTRDReconstructor::GetMaxStep())){
+ //seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
+ continue;
+ }
+ if(!AdjustSector(&track)){
+ //seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
+ continue;
+ }
+ if(TMath::Abs(track.GetSnp()) > AliTRDReconstructor::GetMaxSnp()) {
+ //seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
+ continue;
+ }
+ AliDebug(2, Form("Propagate %s seed[%4d] ESDidx[%4d].", seeder[iSeeder], iSeed, currentIndexESD));
+ nGoodSeeds[iSeeder]++;
+ // store track status at TRD entrance
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup);
- if(expectedClr){
- nFound++;
- // computes PID for track
- track.CookPID();
- // update calibration references using this track
- if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
+ // prepare track and do propagation in the TRD
+ track.SetReconstructor(fkReconstructor);
+ track.SetKink(Bool_t(seed->GetKinkIndex(0)));
+ track.SetPrimary(status & AliESDtrack::kTPCin);
+ track.SetNonTPCseeded(!kTPC);
+ expectedClr = FollowBackProlongation(track);
// save calibration object
- if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
+ if (fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 0) {
AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
calibTrack->SetOwner();
seed->AddCalibObject(calibTrack);
}
- //update ESD track
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
- track.UpdateESDtrack(seed);
- }
+ // printf("track idx[%4d] nCl[%3d] TrkIn[%p]\n", index[iSeed], expectedClr, (void*)track.GetTrackIn());
- if ((TMath::Abs(track.GetC(track.GetBz()) - p4) / TMath::Abs(p4) < 0.2) ||(track.Pt() > 0.8)) {
+ // check if track entered the TRD fiducial volume
+ if(!track.GetTrackIn()){
+ AliDebug(2, Form("TRD missed by %s seed[%4d] ESDidx[%4d].", seeder[iSeeder], iSeed, currentIndexESD));
+ continue;
+ }
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDin);
+ nTRDseeds++;
+
+ // check if track was stopped in the TRD
+ if(expectedClr==-999){
+ AliDebug(1, Form("Track @ idx[%4d] failed prolongation due to track error [%d]", currentIndexESD, track.GetStatusTRD()));
+ continue;
+ } else if(expectedClr==0){
+ AliDebug(1, Form("Track @ idx[%4d] failed prolongation due to layer error [%d %d %d %d %d %d]", currentIndexESD,
+ track.GetStatusTRD(0), track.GetStatusTRD(1), track.GetStatusTRD(2), track.GetStatusTRD(3), track.GetStatusTRD(4), track.GetStatusTRD(5)));
+ continue;
+ } else {
+ AliDebug(2, Form("Track @ idx[%4d] #cl[%3d] expect[%+3d]", currentIndexESD, track.GetNumberOfClusters(), expectedClr));
+ nFound[kTPC]++;
+ // compute PID
+ track.CookPID();
+ //compute MC label
+ track.CookLabel(1. - AliTRDReconstructor::GetLabelFraction());
+ // update calibration references using this track
+ if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
+ //update ESD track
+ seed->UpdateTrackParams(&track, expectedClr>0?AliESDtrack::kTRDout:AliESDtrack::kTRDStop);
+ seed->SetTRDBudget(track.GetBudget(0));
+ track.UpdateESDtrack(seed);
+ if(expectedClr<0) continue;
+ }
// Make backup for back propagation
- Int_t foundClr = track.GetNumberOfClusters();
- if (foundClr >= foundMin) {
- track.CookLabel(1. - fgkLabelFraction);
- //if(track.GetBackupTrack()) UseClusters(track.GetBackupTrack());
-
- // Sign only gold tracks
- if (track.GetChi2() / track.GetNumberOfClusters() < 4) {
- //if ((seed->GetKinkIndex(0) == 0) && (track.Pt() < 1.5)) UseClusters(&track);
- }
- Bool_t isGold = kFALSE;
-
- // Full gold track
- if (track.GetChi2() / track.GetNumberOfClusters() < 5) {
- if (track.GetBackupTrack()) seed->UpdateTrackParams(track.GetBackupTrack(),AliESDtrack::kTRDbackup);
+ 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) {
+ //if(track.GetBackupTrack()) UseClusters(track.GetBackupTrack());
+
+ // Sign only gold tracks
+ if (track.GetChi2() / track.GetNumberOfClusters() < 4) {
+ //if ((seed->GetKinkIndex(0) == 0) && (track.Pt() < 1.5)) UseClusters(&track);
+ }
+ Bool_t isGold = kFALSE;
- isGold = kTRUE;
- }
-
- // Almost gold track
- if ((!isGold) && (track.GetNCross() == 0) && (track.GetChi2() / track.GetNumberOfClusters() < 7)) {
- //seed->UpdateTrackParams(track, AliESDtrack::kTRDbackup);
- if (track.GetBackupTrack()) seed->UpdateTrackParams(track.GetBackupTrack(),AliESDtrack::kTRDbackup);
-
- isGold = kTRUE;
- }
-
- if ((!isGold) && (track.GetBackupTrack())) {
- if ((track.GetBackupTrack()->GetNumberOfClusters() > foundMin) && ((track.GetBackupTrack()->GetChi2()/(track.GetBackupTrack()->GetNumberOfClusters()+1)) < 7)) {
- seed->UpdateTrackParams(track.GetBackupTrack(),AliESDtrack::kTRDbackup);
+ // Full gold track
+ if (track.GetChi2() / track.GetNumberOfClusters() < 5) {
+ if (track.GetBackupTrack()) seed->UpdateTrackParams(track.GetBackupTrack(),AliESDtrack::kTRDbackup);
+ nBacked++;
+ isGold = kTRUE;
+ }
+
+ // Almost gold track
+ if ((!isGold) && (track.GetNCross() == 0) && (track.GetChi2() / track.GetNumberOfClusters() < 7)) {
+ //seed->UpdateTrackParams(track, AliESDtrack::kTRDbackup);
+ if (track.GetBackupTrack()) seed->UpdateTrackParams(track.GetBackupTrack(),AliESDtrack::kTRDbackup);
+ nBacked++;
isGold = kTRUE;
}
+
+ if ((!isGold) && (track.GetBackupTrack())) {
+ if ((track.GetBackupTrack()->GetNumberOfClusters() > foundMin) && ((track.GetBackupTrack()->GetChi2()/(track.GetBackupTrack()->GetNumberOfClusters()+1)) < 7)) {
+ seed->UpdateTrackParams(track.GetBackupTrack(),AliESDtrack::kTRDbackup);
+ nBacked++;
+ isGold = kTRUE;
+ }
+ }
}
}
- }
-
- // Propagation to the TOF
- if(!(seed->GetStatus()&AliESDtrack::kTRDStop)) {
- Int_t sm = track.GetSector();
- // default value in case we have problems with the geometry.
- Double_t xtof = 371.;
- //Calculate radial position of the beginning of the TOF
- //mother volume. In order to avoid mixing of the TRD
- //and TOF modules some hard values are needed. This are:
- //1. The path to the TOF module.
- //2. The width of the TOF (29.05 cm)
- //(with the help of Annalisa de Caro Mar-17-2009)
- if(gGeoManager){
- gGeoManager->cd(Form("/ALIC_1/B077_1/BSEGMO%d_1/BTOF%d_1", sm, sm));
- TGeoHMatrix *m = NULL;
- Double_t loc[]={0., 0., -.5*29.05}, glob[3];
-
- if((m=gGeoManager->GetCurrentMatrix())){
- m->LocalToMaster(loc, glob);
- xtof = TMath::Sqrt(glob[0]*glob[0]+glob[1]*glob[1]);
+
+ // Propagation to the TOF
+ if(!(seed->GetStatus()&AliESDtrack::kTRDStop)) {
+ Int_t sm = track.GetSector();
+ // default value in case we have problems with the geometry.
+ Double_t xtof = 371.;
+ //Calculate radial position of the beginning of the TOF
+ //mother volume. In order to avoid mixing of the TRD
+ //and TOF modules some hard values are needed. This are:
+ //1. The path to the TOF module.
+ //2. The width of the TOF (29.05 cm)
+ //(with the help of Annalisa de Caro Mar-17-2009)
+ if(gGeoManager){
+ gGeoManager->cd(Form("/ALIC_1/B077_1/BSEGMO%d_1/BTOF%d_1", sm, sm));
+ TGeoHMatrix *m = NULL;
+ Double_t loc[]={0., 0., -.5*29.05}, glob[3];
+
+ if((m=gGeoManager->GetCurrentMatrix())){
+ m->LocalToMaster(loc, glob);
+ xtof = TMath::Sqrt(glob[0]*glob[0]+glob[1]*glob[1]);
+ }
}
+ if(xtof > (AliTRDReconstructor::GetMaxStep() + track.GetX()) && !PropagateToX(track, xtof, AliTRDReconstructor::GetMaxStep())){
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
+ continue;
+ }
+ if(!AdjustSector(&track)){
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
+ continue;
+ }
+ if(TMath::Abs(track.GetSnp()) > AliTRDReconstructor::GetMaxSnp()){
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
+ continue;
+ }
+ //seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
+ // TODO obsolete - delete
+ seed->SetTRDQuality(track.StatusForTOF());
}
- if(xtof > (fgkMaxStep + track.GetX()) && !PropagateToX(track, xtof, fgkMaxStep)){
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
- continue;
- }
- if(!AdjustSector(&track)){
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
- continue;
- }
- if(TMath::Abs(track.GetSnp()) > fgkMaxSnp){
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
- continue;
- }
- //seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
- // TODO obsolete - delete
- seed->SetTRDQuality(track.StatusForTOF());
}
- seed->SetTRDBudget(track.GetBudget(0));
+ if(index[iSeeder]) delete [] index[iSeeder];
+ if(idxESD[iSeeder]) delete [] idxESD[iSeeder];
+ if(quality[iSeeder]) delete [] quality[iSeeder];
}
- if(index) delete [] index;
- if(quality) delete [] quality;
- AliInfo(Form("Number of seeds: TPCout[%d] TRDin[%d]", nTPCseeds, nTRDseeds));
- AliInfo(Form("Number of tracks: TRDout[%d]", nFound));
+ AliInfo(Form("Number of seeds: ITSout[%4d] TPCout[%4d] TRDin[%4d]", nGoodSeeds[0], nGoodSeeds[1], nTRDseeds));
+ AliInfo(Form("Number of tracks: TRDout[%4d = %4d + %4d] TRDbackup[%4d]", nFound[0]+nFound[1], nFound[0], nFound[1], nBacked));
// run stand alone tracking
if (fkReconstructor->IsSeeding()) Clusters2Tracks(event);
for (Int_t itrack = 0; itrack < event->GetNumberOfTracks(); itrack++) {
AliESDtrack *seed = event->GetTrack(itrack);
ULong_t status = seed->GetStatus();
-
+ // reject tracks which did not entered TRD from bellow (also produced by the TRD stand alone tracker)
+ if(!(status & AliESDtrack::kTRDin)) continue;
+ // reject TRD tracks with no clusters. This condition is softer than previously used
+ // !(status & AliESDtrack::kTRDout)
+ // since it allows also tracks stopped
+ if(!seed->GetTRDncls()) continue;
+ // check back-up quality
new(&track) AliTRDtrackV1(*seed);
if (track.GetX() < 270.0) {
seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup);
continue;
}
-
- // reject tracks which failed propagation in the TRD or
- // are produced by the TRD stand alone tracker
- if(!(status & AliESDtrack::kTRDout)) continue;
- if(!(status & AliESDtrack::kTRDin)) continue;
- nseed++;
+ nseed++;
track.ResetCovariance(50.0);
// do the propagation and processing
Bool_t kUPDATE = kFALSE;
- Double_t xTPC = 250.0;
+ Double_t xToGo = 250.;//(status & AliESDtrack::kTPCout)?250.0:.1;
if(FollowProlongation(track)){
- // Prolongate to TPC
- if (PropagateToX(track, xTPC, fgkMaxStep)) { // -with update
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDrefit);
- found++;
- kUPDATE = kTRUE;
- }
-
// Update the friend track
- if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
+ if (fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
TObject *o = NULL; Int_t ic = 0;
AliTRDtrackV1 *calibTrack = NULL;
while((o = seed->GetCalibObject(ic++))){
if(!(calibTrack = dynamic_cast<AliTRDtrackV1*>(o))) continue;
- calibTrack->SetTrackHigh(track.GetTrackHigh());
+ calibTrack->SetTrackOut(&track);
}
}
+
+ // Prolongate to TPC
+ if (PropagateToX(track, xToGo, 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, xToGo, AliTRDReconstructor::GetMaxStep())) seed->UpdateTrackParams(&tt, AliESDtrack::kTRDbackup);
}
}
AliInfo(Form("Number of seeds: TRDout[%d]", nseed));
// Debug level 2
//
- Bool_t kStoreIn = kTRUE;
Int_t nClustersExpected = 0;
for (Int_t iplane = kNPlanes; iplane--;) {
Int_t index(-1);
}
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()){
+ AliDebug(2, Form("Reject x[%7.3f] > track[%7.3f]", 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
t.PropagateTo(x, xx0, xrho);
if (!AdjustSector(&t)) break;
}
- if(kStoreIn){
- t.SetTrackHigh();
- kStoreIn = kFALSE;
- }
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();
}
}
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 1){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 1){
Int_t index;
for(int iplane=0; iplane<AliTRDgeometry::kNlayer; iplane++){
AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
Double_t driftLength = .5*AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick();
AliTRDtrackingChamber *chamber = NULL;
- Int_t debugLevel = fkReconstructor->IsDebugStreaming() ? fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) : 0;
+ Int_t debugLevel = fkReconstructor->IsDebugStreaming() ? fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) : 0;
TTreeSRedirector *cstreamer = fkReconstructor->IsDebugStreaming() ? fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker) : 0x0;
+ 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
+
+ Int_t startLayer(0);
AliTRDseedV1 tracklet, *ptrTracklet = NULL;
- // in case of stand alone tracking we store all the pointers to the tracklets in a temporary array
+ // Special case for stand alone tracking
+ // - store all tracklets found by seeding
+ // - start propagation from first tracklet found
AliTRDseedV1 *tracklets[kNPlanes];
memset(tracklets, 0, sizeof(AliTRDseedV1 *) * kNPlanes);
- for(Int_t ip = 0; ip < kNPlanes; ip++){
- tracklets[ip] = t.GetTracklet(ip);
+ for(Int_t ip(kNPlanes); ip--;){
+ if(!(tracklets[ip] = t.GetTracklet(ip))) continue;
t.UnsetTracklet(ip);
+ if(tracklets[ip]->IsOK()) startLayer=ip;
+ kStandAlone = kTRUE;
+ kUseTRD = kTRUE;
}
- Bool_t kStoreIn = kTRUE, kPropagateIn = kTRUE;
+ AliDebug(4, Form("SA[%c] Start[%d]\n"
+ " [0]idx[%d] traklet[%p]\n"
+ " [1]idx[%d] traklet[%p]\n"
+ " [2]idx[%d] traklet[%p]\n"
+ " [3]idx[%d] traklet[%p]\n"
+ " [4]idx[%d] traklet[%p]\n"
+ " [5]idx[%d] traklet[%p]"
+ , kStandAlone?'y':'n', startLayer
+ , t.GetTrackletIndex(0), (void*)tracklets[0]
+ , t.GetTrackletIndex(1), (void*)tracklets[1]
+ , t.GetTrackletIndex(2), (void*)tracklets[2]
+ , t.GetTrackletIndex(3), (void*)tracklets[3]
+ , t.GetTrackletIndex(4), (void*)tracklets[4]
+ , t.GetTrackletIndex(5), (void*)tracklets[5]));
// Loop through the TRD layers
TGeoHMatrix *matrix = NULL;
- Double_t x, y, z;
- for (Int_t ily=0, sm=-1, stk=-1, det=-1; ily < AliTRDgeometry::kNlayer; ily++) {
+ 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);
+ n= n?-n:-999;
+ 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)){
- n=-1;
- t.SetStatus(AliTRDtrackV1::kPropagation);
+ if(fR[ily] > (AliTRDReconstructor::GetMaxStep() + t.GetX()) && !PropagateToX(t, fR[ily], AliTRDReconstructor::GetMaxStep())){
+ n= n?-n:-999;
+ t.SetErrStat(AliTRDtrackV1::kPropagation);
AliDebug(4, "Failed Propagation [Missing Geometry]");
break;
}
if(!AdjustSector(&t)){
- n=-1;
- t.SetStatus(AliTRDtrackV1::kAdjustSector);
+ n= n?-n:-999;
+ t.SetErrStat(AliTRDtrackV1::kAdjustSector);
AliDebug(4, "Failed Adjust Sector [Missing Geometry]");
break;
}
- if(TMath::Abs(t.GetSnp()) > fgkMaxSnp){
- n=-1;
- t.SetStatus(AliTRDtrackV1::kSnp);
+ if(TMath::Abs(t.GetSnp()) > AliTRDReconstructor::GetMaxSnp()){
+ n= n?-n:-999;
+ 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 D%3d[%02d_%d_%d] x_anode[%7.2f] (%f %f)", det, sm, stk, ily, 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)){
- n=-1;
- t.SetStatus(AliTRDtrackV1::kPropagation);
- AliDebug(4, Form("Failed Initial Propagation to x[%7.2f]", x));
+ x = glb[0] - AliTRDReconstructor::GetMaxStep();
+ if(x > (AliTRDReconstructor::GetMaxStep() + t.GetX()) && !PropagateToX(t, x, AliTRDReconstructor::GetMaxStep())){
+ n= n?-n:-999;
+ t.SetErrStat(AliTRDtrackV1::kPropagation);
+ AliDebug(4, Form("Failed Propagation to x[%7.2f]", x));
break;
}
if(!AdjustSector(&t)){
- n=-1;
- t.SetStatus(AliTRDtrackV1::kAdjustSector);
+ n= n?-n:-999;
+ t.SetErrStat(AliTRDtrackV1::kAdjustSector);
AliDebug(4, "Failed Adjust Sector Start");
break;
}
- if(TMath::Abs(t.GetSnp()) > fgkMaxSnp) {
- n=-1;
- t.SetStatus(AliTRDtrackV1::kSnp);
- AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), fgkMaxSnp));
+ if(TMath::Abs(t.GetSnp()) > AliTRDReconstructor::GetMaxSnp()) {
+ n= n?-n:-999;
+ t.SetErrStat(AliTRDtrackV1::kSnp);
+ AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), AliTRDReconstructor::GetMaxSnp()));
break;
}
Bool_t doRecalculate = kFALSE;
if(sm != t.GetSector()){
+ AliDebug(3, Form("Track crossed sectors %2d -> %2d", sm, t.GetSector()));
sm = t.GetSector();
doRecalculate = kTRUE;
}
if(stk != fGeom->GetStack(z, ily)){
+ AliDebug(3, Form("Track crossed stacks %d -> %d in sec[%02d]", stk, fGeom->GetStack(z, ily), sm));
stk = fGeom->GetStack(z, ily);
doRecalculate = kTRUE;
}
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)) {
- 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));
+ if (!t.GetProlongation(x+AliTRDReconstructor::GetMaxStep(), y, z)) {
+ n= n?-n:-999;
+ 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.SetTrackLow();
+ t.SetTrackIn();
kStoreIn = kFALSE;
}
AliDebug(3, Form("Building tracklet det[%d]", det));
// check data in supermodule
if(!fTrSec[sm].GetNChambers()){
- t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
- AliDebug(4, "Failed NoClusters");
+ t.SetErrStat(AliTRDtrackV1::kNoClusters, ily);
+ AliDebug(4, Form("Failed NoClusters in sec[%02d]", sm));
continue;
}
if(fTrSec[sm].GetX(ily) < 1.){
- t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
- AliDebug(4, "Failed NoX");
+ t.SetErrStat(AliTRDtrackV1::kNoClusters, ily);
+ AliDebug(4, Form("Failed NoX in sec[%02d]", sm));
continue;
}
// check data in chamber
if(!(chamber = fTrSec[sm].GetChamber(stk, ily))){
- t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
- AliDebug(4, "Failed No Detector");
+ t.SetErrStat(AliTRDtrackV1::kNoClusters, ily);
+ AliDebug(4, Form("Failed No Data for D%03d[%02d_%d_%d]", AliTRDgeometry::GetDetector(ily, stk, sm), sm, stk, ily));
continue;
}
- if(chamber->GetNClusters() < fgNTimeBins*fkReconstructor->GetRecoParam() ->GetFindableClusters()){
- t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
- AliDebug(4, "Failed Not Enough Clusters in Detector");
+ if(chamber->GetNClusters() < fgNTimeBins*fkRecoParam ->GetFindableClusters()){
+ t.SetErrStat(AliTRDtrackV1::kNoClusters, ily);
+ AliDebug(4, Form("Failed Not Enough Clusters[%2d] for D%03d[%02d_%d_%d]", chamber->GetNClusters(), AliTRDgeometry::GetDetector(ily, stk, sm), sm, stk, ily));
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)){
- n=-1;
- t.SetStatus(AliTRDtrackV1::kTrackletInit);
+ if(!ptrTracklet->Init(&t)){
+ n= n?-n:-999;
+ 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*fkReconstructor->GetRecoParam() ->GetFindableClusters()){
- t.SetStatus(AliTRDtrackV1::kNoClustersTracklet, ily);
+ Int_t nClTracklet(ptrTracklet->GetN());
+ AliDebug(3, Form("Number of Clusters in Tracklet: %2d", nClTracklet));
+ if(nClTracklet < Int_t(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";
}
- AliDebug(4, "Failed N Clusters Attached");
+ AliDebug(4, Form("Attached clusters %2d<%2d (%4.1f%% of TB[%2d])", nClTracklet, Int_t(fgNTimeBins*fkRecoParam->GetFindableClusters()), 1.e2*fkRecoParam->GetFindableClusters(), fgNTimeBins));
continue;
}
ptrTracklet->UpdateUsed();
+ // protect against reattaching clusters
+ if(Float_t(ptrTracklet->GetNUsed())/nClTracklet > .5/*fkRecoParam->GetUsedClustersLimit()*/){
+ t.SetErrStat(AliTRDtrackV1::kNoClustersTracklet, ily);
+ AliDebug(4, Form("Used clusters %2d[%4.1f%%] exceed limit [%4.1f%%]", nClTracklet, Float_t(ptrTracklet->GetNUsed())/nClTracklet, 1.e2*.5/*fkRecoParam->GetUsedClustersLimit()*/));
+ continue;
+ }
} else AliDebug(2, Form("Use external tracklet ly[%d]", ily));
// propagate track to the radial position of the tracklet
- ptrTracklet->UseClusters(); // TODO ? do we need this here ?
- // 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)) {
- n=-1;
- t.SetStatus(AliTRDtrackV1::kPropagation);
+ if(x > (AliTRDReconstructor::GetMaxStep() + t.GetX()) && !PropagateToX(t, x, AliTRDReconstructor::GetMaxStep())) {
+ n= n?-n:-999;
+ 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);
+ n= n?-n:-999;
+ t.SetErrStat(AliTRDtrackV1::kAdjustSector);
AliDebug(4, "Failed Adjust Sector");
break;
}
- if(TMath::Abs(t.GetSnp()) > fgkMaxSnp) {
- n=-1;
- t.SetStatus(AliTRDtrackV1::kSnp);
- AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), fgkMaxSnp));
+ if(TMath::Abs(t.GetSnp()) > AliTRDReconstructor::GetMaxSnp()) {
+ n= n?-n:-999;
+ t.SetErrStat(AliTRDtrackV1::kSnp);
+ AliDebug(4, Form("Failed Max Snp[%f] MaxSnp[%f]", t.GetSnp(), AliTRDReconstructor::GetMaxSnp()));
break;
}
- if(kPropagateIn){
- t.SetTrackLow();
- kPropagateIn = kFALSE;
- }
+ // update parameters of track in.
+ if(!ily) t.SetTrackIn();
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)) {
- 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";
+ if(kUseTRD){
+ if(!((AliExternalTrackParam&)t).Update(p, cov)) {
+ n= n?-n:-999;
+ 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));
// if(ilayer>0 && t.GetTracklet(ilayer-1) && ptrTracklet->GetN() + t.GetTracklet(ilayer-1)->GetN() > 20) t.SetBudget(2, 0.);
// Make backup of the track until is gold
- // TO DO update quality check of the track.
- // consider comparison with fTimeBinsRange
- Float_t ratio0 = ptrTracklet->GetN() / Float_t(fgNTimeBins);
- //Float_t ratio1 = Float_t(t.GetNumberOfClusters()+1) / Float_t(t.GetNExpected()+1);
-
- if( (chi2 < 18.0) &&
- (ratio0 > 0.8) &&
- //(ratio1 > 0.6) &&
- //(ratio0+ratio1 > 1.5) &&
- (t.GetNCross() == 0) &&
- (TMath::Abs(t.GetSnp()) < 0.85) &&
- (t.GetNumberOfClusters() > 20)){
- t.MakeBackupTrack();
- }
+ Int_t failed(0);
+ if(!kStandAlone && (failed = t.MakeBackupTrack())) AliDebug(2, Form("Failed backup on cut[%d]", failed));
+
} // end layers loop
//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;
x = cl->GetX();
y = cl->GetY();
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);
+ tracklets[ip].SetC(curvature, 1);
+
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>3) printf("D-AliTRDtrackerV1::FitTiltedRiemanConstraint: Chi2[%f] C[%5.2e] pt[%8.3f]\n", chi2track, curvature, GetBz()*kB2C/curvature);
/* if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker()) >= 5){
//Linear Model on z-direction
nPoints++;
}
}
- fitter->Eval();
+ if (fitter->Eval()) return 1.e10;
zfitter.Eval();
Double_t offset = fitter->GetParameter(3);
Double_t b = fitter->GetParameter(1);
Double_t c = fitter->GetParameter(2);
Double_t curvature = 1.0 + b*b - c*a;
- if (curvature > 0.0)
- curvature = a / TMath::Sqrt(curvature);
+ if (curvature > 0.0) curvature = a / TMath::Sqrt(curvature);
Double_t chi2track = fitter->GetChisquare()/Double_t(nPoints);
tracklets[iLayer].SetCovRef(cov);
tracklets[iLayer].SetChi2(chi2track);
}
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>3) printf("D-AliTRDtrackerV1::FitTiltedRieman: Chi2[%f] C[%5.2e] pt[%8.3f]\n", chi2track, curvature, GetBz()*kB2C/curvature);
/* if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >=5){
TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
}
Double_t xref = CalculateReferenceX(tracklets);
- AliDebugGeneral("AliTRDtrackerV1::FitRiemanTilt()", 4,
- Form("\nx0[(0)%6.2f (1)%6.2f (2)%6.2f (3)%6.2f (4)%6.2f (5)%6.2f] xref[%6.2f]", tracklets[0].GetX0(), tracklets[1].GetX0(), tracklets[2].GetX0(), tracklets[3].GetX0(), tracklets[4].GetX0(), tracklets[5].GetX0(), xref));
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>3) printf("D-AliTRDtrackerV1::FitRiemanTilt:\nx0[(0)%6.2f (1)%6.2f (2)%6.2f (3)%6.2f (4)%6.2f (5)%6.2f] xref[%6.2f]", tracklets[0].GetX0(), tracklets[1].GetX0(), tracklets[2].GetX0(), tracklets[3].GetX0(), tracklets[4].GetX0(), tracklets[5].GetX0(), xref);
Double_t x, y, z, t, tilt, dx, w, we;
Double_t uvt[4];
Int_t nPoints = 0;
// Calculate chi2 of the fit
Double_t chi2 = fitter->GetChisquare()/Double_t(nPoints);
- AliDebugGeneral("AliTRDtrackerV1::FitRiemanTilt()", 4,
- Form("x0[%6.2f] y0[%6.2f] R[%6.2f] chi2[%f]\n", x0, y0, radius, chi2));
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")>3) printf("D-AliTRDtrackerV1::FitRiemanTilt:x0[%6.2f] y0[%6.2f] R[%6.2f] chi2[%f]\n", x0, y0, radius, chi2);
// Update the tracklets
if(!track){
//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 = fkReconstructor->GetRecoParam()->GetNClusters();
+ 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;
}
//_____________________________________________________________________________
// Fills clusters into TRD tracking sectors
//
+ fkRecoParam = fkReconstructor->GetRecoParam(); // load reco param for this event
+
if(!fkReconstructor->IsWritingClusters()){
fClusters = AliTRDReconstructor::GetClusters();
} else {
- if (ReadClusters(fClusters, cTree)) {
+ if(!ReadClusters(cTree)) {
AliError("Problem with reading the clusters !");
return 1;
}
fClusters = clusters;
SetClustersOwner();
- //Int_t nin =
+ fkRecoParam = fkReconstructor->GetRecoParam(); // load reco param for this event
BuildTrackingContainers();
//Int_t ncl = fClusters->GetEntriesFast();
{
// Building tracking containers for clusters
- Int_t nin =0, icl = fClusters->GetEntriesFast();
- while (icl--) {
- AliTRDcluster *c = (AliTRDcluster *) fClusters->UncheckedAt(icl);
+ Int_t nin(0), ncl(fClusters->GetEntriesFast());
+ while (ncl--) {
+ AliTRDcluster *c = (AliTRDcluster *) fClusters->UncheckedAt(ncl);
if(c->IsInChamber()) nin++;
if(fkReconstructor->IsHLT()) c->SetRPhiMethod(AliTRDcluster::kCOG);
Int_t detector = c->GetDetector();
Int_t stack = fGeom->GetStack(detector);
Int_t layer = fGeom->GetLayer(detector);
- fTrSec[sector].GetChamber(stack, layer, kTRUE)->InsertCluster(c, icl);
+ fTrSec[sector].GetChamber(stack, layer, kTRUE)->InsertCluster(c, ncl);
}
- const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
for(int isector =0; isector<AliTRDgeometry::kNsector; isector++){
if(!fTrSec[isector].GetNChambers()) continue;
- fTrSec[isector].Init(fkReconstructor, cal);
+ fTrSec[isector].Init(fkReconstructor);
}
return nin;
//____________________________________________________________________
-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
return new ((*fTracklets)[nentries]) AliTRDseedV1(*tracklet);
}
-//____________________________________________________________________
-void AliTRDtrackerV1::CookNTimeBins()
-{
- // Initialize number of time bins
-
- if(fgNTimeBins){
- // first look if set by hand
- AliDebug(2, Form("NTimeBins [%d] (set by user)", fgNTimeBins));
- } else if(fkReconstructor && fkReconstructor->HasDigitsParam()) {
- // second look into digits param to avoid DB query
- fgNTimeBins = fkReconstructor->GetDigitsParam()->GetNTimeBins();
- if(fgNTimeBins>0) AliDebug(2, Form("NTimeBins [%d] (set from digits param)", fgNTimeBins));
- else AliWarning(Form("NTimeBins [%d] failed from digits param.", fgNTimeBins));
- }
-
- if(!fgNTimeBins){ // third query DB
- AliTRDcalibDB *trd(NULL);
- if((trd = AliTRDcalibDB::Instance())) {
- if((fgNTimeBins = trd->GetNumberOfTimeBinsDCS()) <= 0){
- AliError("Corrupted DCS Object in OCDB");
- fgNTimeBins = 24;
- AliDebug(2, Form("NTimeBins [%d] (set to default 24)", fgNTimeBins));
- } else AliDebug(2, Form("NTimeBins [%d] (set from DB)", fgNTimeBins));
- } else AliFatal("Could not get DB.");
- }
-
- if(fgNTimeBins<=0){
- AliError("NTimeBins failed all settings. Use default 24 !");
- fgNTimeBins = 24;
- }
-}
-
//____________________________________________________________________
AliTRDtrackV1* AliTRDtrackerV1::SetTrack(const AliTRDtrackV1 * const track)
{
nChambers = 0;
for(int ilayer=0; ilayer<AliTRDgeometry::kNlayer; ilayer++){
if(!(chamber = stack[ilayer])) continue;
- if(chamber->GetNClusters() < fgNTimeBins * fkReconstructor->GetRecoParam() ->GetFindableClusters()) continue;
+ if(chamber->GetNClusters() < fgNTimeBins * fkRecoParam->GetFindableClusters()) continue;
nChambers++;
//AliInfo(Form("sector %d stack %d layer %d clusters %d", sector, istack, ilayer, chamber->GetNClusters()));
}
Int_t id = esd->AddTrack(esdTrack);
// set ESD id to stand alone TRD tracks
- if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
+ if (fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
esdTrack=esd->GetTrack(id);
TObject *o(NULL); Int_t ic(0);
AliTRDtrackV1 *calibTrack(NULL);
// 8. Build ESD track and register it to the output list
//
- const AliTRDCalDet *cal = AliTRDcalibDB::Instance()->GetT0Det();
AliTRDtrackingChamber *chamber = NULL;
AliTRDtrackingChamber **ci = NULL;
AliTRDseedV1 sseed[kMaxTracksStack*6]; // to be initialized
// Build initial seeding configurations
Double_t quality = BuildSeedingConfigs(stack, configs);
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 10){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 10){
AliInfo(Form("Plane config %d %d %d Quality %f"
, configs[0], configs[1], configs[2], quality));
}
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 == kMaxTracksStack) break;
}
AliDebug(2, Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
-
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:");
+ for (Int_t it(0); it < ntracks; it++) {
+ Int_t jt(sort[it]);
+ printf(" %2d idx[%d] Quality[%e]\n", it, jt, fTrackQuality[jt]);
+ }
+ }
// Initialize number of tracks so far and logic switches
Int_t ntracks0 = esdTrackList->GetEntriesFast();
//AliInfo("Selecting track candidates ...");
// Sieve clusters in decreasing order of track quality
- Double_t trackParams[7];
- // AliTRDseedV1 *lseed = NULL;
- Int_t jSieve = 0, candidates;
+ Int_t jSieve(0), rejectedCandidates(0);
do{
- //AliInfo(Form("\t\tITER = %i ", jSieve));
-
// Check track candidates
- candidates = 0;
+ rejectedCandidates=0;
for (Int_t itrack = 0; itrack < ntracks; itrack++) {
Int_t trackIndex = sort[itrack];
if (signedTrack[trackIndex] || fakeTrack[trackIndex]) continue;
-
// Calculate track parameters from tracklets seeds
Int_t ncl = 0;
Int_t findable = 0;
for (Int_t jLayer = 0; jLayer < kNPlanes; jLayer++) {
Int_t jseed = kNPlanes*trackIndex+jLayer;
+ sseed[jseed].UpdateUsed();
if(!sseed[jseed].IsOK()) continue;
+ // check if primary candidate
if (TMath::Abs(sseed[jseed].GetYref(0) / sseed[jseed].GetX0()) < 0.158) findable++;
- // TODO here we get a sig fault which should never happen !
- sseed[jseed].UpdateUsed();
- ncl += sseed[jseed].GetN2();
+ ncl += sseed[jseed].GetN();
nused += sseed[jseed].GetNUsed();
nlayers++;
}
// Filter duplicated tracks
if (nused > 30){
- //printf("Skip %d nused %d\n", trackIndex, nused);
+ AliDebug(4, Form("REJECTED : %d idx[%d] quality[%e] tracklets[%d] usedClusters[%d]", itrack, trackIndex, fTrackQuality[trackIndex], nlayers, nused));
fakeTrack[trackIndex] = kTRUE;
continue;
}
if (ncl>0 && Float_t(nused)/ncl >= .25){
- //printf("Skip %d nused/ncl >= .25\n", trackIndex);
+ AliDebug(4, Form("REJECTED : %d idx[%d] quality[%e] tracklets[%d] usedClusters[%d] used/ncl[%f]", itrack, trackIndex, fTrackQuality[trackIndex], nlayers, nused, Float_t(nused)/ncl));
fakeTrack[trackIndex] = kTRUE;
continue;
}
+ AliDebug(4, Form("Candidate[%d] Quality[%e] Tracklets[%d] Findable[%d] Ncl[%d] Nused[%d]", trackIndex, fTrackQuality[trackIndex], nlayers, findable, ncl, nused));
+
// Classify tracks
Bool_t skip = kFALSE;
switch(jSieve){
- case 0:
- if(nlayers < 6) {skip = kTRUE; break;}
+ case 0: // select 6 tracklets primary tracks, good quality
+ if(nlayers > findable || nlayers < kNPlanes) {skip = kTRUE; break;}
if(TMath::Log(1.E-9+fTrackQuality[trackIndex]) < -5.){skip = kTRUE; break;}
break;
- case 1:
+ case 1: // select shorter primary tracks, good quality
+ //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;
- case 2:
- if ((nlayers == findable) || (nlayers == 6)) { skip = kTRUE; break;}
+ case 2: // select 6 tracklets secondary tracks
+ if(nlayers < kNPlanes) { skip = kTRUE; break;}
if (TMath::Log(1.E-9+fTrackQuality[trackIndex]) < -6.0){skip = kTRUE; break;}
break;
- case 3:
+ case 3: // select shorter tracks, good quality
+ if (nlayers<4){skip = kTRUE; break;}
if (TMath::Log(1.E-9+fTrackQuality[trackIndex]) < -5.){skip = kTRUE; break;}
break;
- case 4:
- if (nlayers == 3){skip = kTRUE; break;}
+ case 4: // select anything with at least 4 tracklets
+ if (nlayers<4){skip = kTRUE; break;}
//if (TMath::Log(1.E-9+fTrackQuality[trackIndex]) - nused/(nlayers-3.0) < -15.0){skip = kTRUE; break;}
break;
}
if(skip){
- candidates++;
+ rejectedCandidates++;
AliDebug(4, Form("REJECTED : %d idx[%d] quality[%e] tracklets[%d] usedClusters[%d]", itrack, trackIndex, fTrackQuality[trackIndex], nlayers, nused));
continue;
} else AliDebug(4, Form("ACCEPTED : %d idx[%d] quality[%e] tracklets[%d] usedClusters[%d]", itrack, trackIndex, fTrackQuality[trackIndex], nlayers, nused));
signedTrack[trackIndex] = kTRUE;
- // Build track parameters
- AliTRDseedV1 *lseed =&sseed[trackIndex*6];
- /* Int_t idx = 0;
- while(idx<3 && !lseed->IsOK()) {
- idx++;
- lseed++;
- }*/
- Double_t x = lseed->GetX0();// - 3.5;
- trackParams[0] = x; //NEW AB
- trackParams[1] = lseed->GetYref(0); // lseed->GetYat(x);
- trackParams[2] = lseed->GetZref(0); // lseed->GetZat(x);
- trackParams[3] = TMath::Sin(TMath::ATan(lseed->GetYref(1)));
- trackParams[4] = lseed->GetZref(1) / TMath::Sqrt(1. + lseed->GetYref(1) * lseed->GetYref(1));
- trackParams[5] = lseed->GetC();
- Int_t ich = 0; while(!(chamber = stack[ich])) ich++;
- trackParams[6] = fGeom->GetSector(chamber->GetDetector());/* *alpha+shift; // Supermodule*/
-
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 1 && fkReconstructor->IsDebugStreaming()){
+ AliTRDseedV1 *lseed =&sseed[trackIndex*kNPlanes];
+ AliTRDtrackV1 *track = MakeTrack(lseed);
+ if(!track){
+ AliDebug(1, "Track building failed.");
+ continue;
+ } else {
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1") > 1){
+ Int_t ich = 0; while(!(chamber = stack[ich])) ich++;
+ AliDebug(2, Form("Track pt=%7.2fGeV/c SM[%2d] Done.", track->Pt(), fGeom->GetSector(chamber->GetDetector())));
+ }
+ }
+
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 1 && fkReconstructor->IsDebugStreaming()){
//AliInfo(Form("Track %d [%d] nlayers %d trackQuality = %e nused %d, yref = %3.3f", itrack, trackIndex, nlayers, fTrackQuality[trackIndex], nused, trackParams[1]));
AliTRDseedV1 *dseed[6];
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
cstreamer << "Clusters2TracksStack"
- << "EventNumber=" << eventNumber
- << "TrackNumber=" << trackNumber
- << "CandidateNumber=" << candidateNumber
- << "Iter=" << fSieveSeeding
- << "Like=" << fTrackQuality[trackIndex]
- << "S0.=" << dseed[0]
- << "S1.=" << dseed[1]
- << "S2.=" << dseed[2]
- << "S3.=" << dseed[3]
- << "S4.=" << dseed[4]
- << "S5.=" << dseed[5]
- << "p0=" << trackParams[0]
- << "p1=" << trackParams[1]
- << "p2=" << trackParams[2]
- << "p3=" << trackParams[3]
- << "p4=" << trackParams[4]
- << "p5=" << trackParams[5]
- << "p6=" << trackParams[6]
- << "Ncl=" << ncl
- << "NLayers=" << nlayers
- << "Findable=" << findable
- << "NUsed=" << nused
+ << "EventNumber=" << eventNumber
+ << "TrackNumber=" << trackNumber
+ << "CandidateNumber=" << candidateNumber
+ << "Iter=" << fSieveSeeding
+ << "Like=" << fTrackQuality[trackIndex]
+ << "S0.=" << dseed[0]
+ << "S1.=" << dseed[1]
+ << "S2.=" << dseed[2]
+ << "S3.=" << dseed[3]
+ << "S4.=" << dseed[4]
+ << "S5.=" << dseed[5]
+ << "Ncl=" << ncl
+ << "NLayers=" << nlayers
+ << "Findable=" << findable
+ << "NUsed=" << nused
<< "\n";
}
- AliTRDtrackV1 *track = MakeTrack(&sseed[trackIndex*kNPlanes], trackParams);
- if(!track){
- AliDebug(1, "Track building failed.");
- continue;
- }
-
- //AliInfo("End of MakeTrack()");
+
AliESDtrack *esdTrack = new ((*esdTrackList)[ntracks0++]) AliESDtrack();
esdTrack->UpdateTrackParams(track, AliESDtrack::kTRDout);
esdTrack->SetLabel(track->GetLabel());
track->UpdateESDtrack(esdTrack);
// write ESD-friends if neccessary
- if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
+ if (fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(*track);
calibTrack->SetOwner();
esdTrack->AddCalibObject(calibTrack);
}
jSieve++;
- } while(jSieve<5 && candidates); // end track candidates sieve
+ } while(jSieve<5 && rejectedCandidates); // end track candidates sieve
if(!ntracks1) break;
// increment counters
for(Int_t ip = 0; ip < kNPlanes; ip++){
if(!(chamber = stack[ip])) continue;
- chamber->Build(fGeom, cal);//Indices(fSieveSeeding);
+ chamber->Build(fGeom);//Indices(fSieveSeeding);
}
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 10){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 10){
AliInfo(Form("Sieve level %d Plane config %d %d %d Quality %f", fSieveSeeding, configs[0], configs[1], configs[2], quality));
}
} while(fSieveSeeding<10); // end stack clusters sieve
}
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];
}
Bool_t isFake = kFALSE;
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
if (c[0]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
if (c[1]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
if (c[2]->GetLabel(0) != c[3]->GetLabel(0)) isFake = kTRUE;
<<"RiemanFitter.=" << rim
<<"\n";
}
- if(chi2[0] > fkReconstructor->GetRecoParam() ->GetChi2Z()/*7./(3. - sLayer)*//*iter*/){
+ if(chi2[0] > fkRecoParam->GetChi2Z()/*7./(3. - sLayer)*//*iter*/){
AliDebug(3, Form("Filter on chi2Z [%f].", chi2[0]));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
- if(chi2[1] > fkReconstructor->GetRecoParam() ->GetChi2Y()/*1./(3. - sLayer)*//*iter*/){
+ if(chi2[1] > fkRecoParam->GetChi2Y()/*1./(3. - sLayer)*//*iter*/){
AliDebug(3, Form("Filter on chi2Y [%f].", chi2[1]));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
if(!cseed[jLayer].AttachClusters(chamber, kTRUE)) continue;
cseed[jLayer].Fit();
}
+ //FitTiltedRiemanConstraint(&cseed[0], GetZ());
fTrackQuality[ntracks] = 1.; // dummy value
ntracks++;
if(ntracks == kMaxTracksStack) return ntracks;
// Update Seeds and calculate Likelihood
// fit tracklets and cook likelihood
- FitTiltedRieman(&cseed[0], kTRUE);
+ Double_t chi2Vals[4];
+ 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 (TMath::Log(1.E-9 + like) < fkReconstructor->GetRecoParam() ->GetTrackLikelihood()){
+ if (TMath::Log(1.E-9 + like) < fkRecoParam->GetTrackLikelihood()){
AliDebug(3, Form("Filter on likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
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;
- FitTiltedRieman(cseed, kTRUE);
- cseed[jLayer].Fit(kTRUE);
+ chi2Vals[0] = FitTiltedRieman(cseed, kTRUE);
+ cseed[jLayer].Fit(1);
elayers++;
}
// AliInfo("Extrapolation done.");
// Debug Stream containing all the 6 tracklets
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
<< "\n";
}
- if(fkReconstructor->GetRecoParam()->HasImproveTracklets()){
- AliTRDseedV1 bseed[AliTRDgeometry::kNlayer];
- for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) bseed[jLayer] = cseed[jLayer];
-
- if(ImproveSeedQuality(stack, cseed) < mlayers+elayers){
+ if(fkRecoParam->HasImproveTracklets()){
+ if(!ImproveSeedQuality(stack, cseed, chi2Vals[0])){
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
- AliDebug(3, "Filter on improve seeds.");
- } else {
- // store results
- for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) cseed[jLayer] = bseed[jLayer];
+ AliDebug(3, "ImproveSeedQuality() failed.");
}
}
- //AliInfo("Improve seed quality done.");
- // fit full track and cook likelihoods
- // Double_t curv = FitRieman(&cseed[0], chi2);
- // Double_t chi2ZF = chi2[0] / TMath::Max((mlayers - 3.), 1.);
- // Double_t chi2RF = chi2[1] / TMath::Max((mlayers - 3.), 1.);
-
- // do the final track fitting (Once with vertex constraint and once without vertex constraint)
- Double_t chi2Vals[3];
- chi2Vals[0] = FitTiltedRieman(&cseed[0], kTRUE);
- if(fkReconstructor->GetRecoParam()->IsVertexConstrained())
- chi2Vals[1] = FitTiltedRiemanConstraint(&cseed[0], GetZ()); // Do Vertex Constrained fit if desired
- else
- chi2Vals[1] = 1.;
- chi2Vals[2] = GetChi2Z(&cseed[0]) / TMath::Max((mlayers - 3.), 1.);
- // Chi2 definitions in testing stage
- //chi2Vals[2] = GetChi2ZTest(&cseed[0]);
- fTrackQuality[ntracks] = CalculateTrackLikelihood(&cseed[0], &chi2Vals[0]);
- //AliInfo("Hyperplane fit done\n");
+ // do track fitting with vertex constraint
+ if(fkRecoParam->IsVertexConstrained()) chi2Vals[1] = FitTiltedRiemanConstraint(&cseed[0], GetZ());
+ else chi2Vals[1] = -1.;
+ chi2Vals[2] = GetChi2Z(&cseed[0]);
+ chi2Vals[3] = GetChi2Phi(&cseed[0]);
+
+ // calculate track quality
+ fTrackQuality[ntracks] = CalculateTrackLikelihood(&chi2Vals[0]);
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
<< "FitterTC.=" << fitterTC
<< "\n";
}
-
+ if(AliLog::GetDebugLevel("TRD", "AliTRDtrackerV1")){
+ Double_t pt[]={0., 0.};
+ for(Int_t il(0); il<kNPlanes; il++){
+ if(!cseed[il].IsOK()) continue;
+ pt[0] = GetBz()*kB2C/cseed[il].GetC();
+ pt[1] = GetBz()*kB2C/cseed[il].GetC(1);
+ break;
+ }
+ AliDebug(2, Form("Candidate[%2d] pt[%7.3f %7.3f] Q[%e]\n"
+ " [0] x[%6.2f] n[%2d] nu[%d] OK[%c]\n"
+ " [1] x[%6.2f] n[%2d] nu[%d] OK[%c]\n"
+ " [2] x[%6.2f] n[%2d] nu[%d] OK[%c]\n"
+ " [3] x[%6.2f] n[%2d] nu[%d] OK[%c]\n"
+ " [4] x[%6.2f] n[%2d] nu[%d] OK[%c]\n"
+ " [5] x[%6.2f] n[%2d] nu[%d] OK[%c]"
+ , ntracks, pt[0], pt[1], fTrackQuality[ntracks]
+ ,cseed[0].GetX(), cseed[0].GetN(), cseed[0].GetNUsed(), cseed[0].IsOK()?'y':'n'
+ ,cseed[1].GetX(), cseed[1].GetN(), cseed[1].GetNUsed(), cseed[1].IsOK()?'y':'n'
+ ,cseed[2].GetX(), cseed[2].GetN(), cseed[2].GetNUsed(), cseed[2].IsOK()?'y':'n'
+ ,cseed[3].GetX(), cseed[3].GetN(), cseed[3].GetNUsed(), cseed[3].IsOK()?'y':'n'
+ ,cseed[4].GetX(), cseed[4].GetN(), cseed[4].GetNUsed(), cseed[4].IsOK()?'y':'n'
+ ,cseed[5].GetX(), cseed[5].GetN(), cseed[5].GetNUsed(), cseed[5].IsOK()?'y':'n'));
+ }
ntracks++;
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
if(ntracks == kMaxTracksStack){
}
//_____________________________________________________________________________
-AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 * const seeds, Double_t *params)
+AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 * const tracklet)
{
//
// Build a TRD track out of tracklet candidates
// 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;
- Double_t c[15];
+ // find first good tracklet
+ Int_t idx(0); while(idx<kNPlanes && !tracklet[idx].IsOK()) idx++;
+ if(idx>2){ AliDebug(1, Form("Found suspect track start @ layer idx[%d]\n"
+ " %c[0] x0[%f] n[%d] nu[%d] OK[%c]\n"
+ " %c[1] x0[%f] n[%d] nu[%d] OK[%c]\n"
+ " %c[2] x0[%f] n[%d] nu[%d] OK[%c]\n"
+ " %c[3] x0[%f] n[%d] nu[%d] OK[%c]\n"
+ " %c[4] x0[%f] n[%d] nu[%d] OK[%c]\n"
+ " %c[5] x0[%f] n[%d] nu[%d] OK[%c]"
+ ,idx
+ ,idx==0?'*':' ', tracklet[0].GetX0(), tracklet[0].GetN(), tracklet[0].GetNUsed(), tracklet[0].IsOK()?'y':'n'
+ ,idx==1?'*':' ', tracklet[1].GetX0(), tracklet[1].GetN(), tracklet[1].GetNUsed(), tracklet[1].IsOK()?'y':'n'
+ ,idx==2?'*':' ', tracklet[2].GetX0(), tracklet[2].GetN(), tracklet[2].GetNUsed(), tracklet[2].IsOK()?'y':'n'
+ ,idx==3?'*':' ', tracklet[3].GetX0(), tracklet[3].GetN(), tracklet[3].GetNUsed(), tracklet[3].IsOK()?'y':'n'
+ ,idx==4?'*':' ', tracklet[4].GetX0(), tracklet[4].GetN(), tracklet[4].GetNUsed(), tracklet[4].IsOK()?'y':'n'
+ ,idx==5?'*':' ', tracklet[5].GetX0(), tracklet[5].GetN(), tracklet[5].GetNUsed(), tracklet[5].IsOK()?'y':'n'));
+ return NULL;
+ }
+
+ Double_t dx(5.);
+ Double_t x(tracklet[idx].GetX0() - dx);
+ // Build track parameters
+ Double_t params[] = {
+ tracklet[idx].GetYref(0) - dx*tracklet[idx].GetYref(1) // y
+ ,tracklet[idx].GetZref(0) - dx*tracklet[idx].GetZref(1) // z
+ ,TMath::Sin(TMath::ATan(tracklet[idx].GetYref(1))) // snp
+ ,tracklet[idx].GetZref(1) / TMath::Sqrt(1. + tracklet[idx].GetYref(1) * tracklet[idx].GetYref(1)) // tgl
+ ,tracklet[idx].GetC(fkReconstructor->IsHLT()?1:0) // curvature -> 1/pt
+ };
+ Int_t sector(fGeom->GetSector(tracklet[idx].GetDetector()));
+
+ Double_t c[15];
c[ 0] = 0.2; // s^2_y
c[ 1] = 0.0; c[ 2] = 2.0; // s^2_z
c[ 3] = 0.0; c[ 4] = 0.0; c[ 5] = 0.02; // s^2_snp
c[ 6] = 0.0; c[ 7] = 0.0; c[ 8] = 0.0; c[ 9] = 0.1; // s^2_tgl
- c[10] = 0.0; c[11] = 0.0; c[12] = 0.0; c[13] = 0.0; c[14] = params[5]*params[5]*0.01; // s^2_1/pt
+ c[10] = 0.0; c[11] = 0.0; c[12] = 0.0; c[13] = 0.0; c[14] = params[4]*params[4]*0.01; // s^2_1/pt
+
+ AliTRDtrackV1 track(tracklet, params, c, x, sector*alpha+shift);
- AliTRDtrackV1 track(seeds, ¶ms[1], c, params[0], params[6]*alpha+shift);
- track.PropagateTo(params[0]-5.0);
AliTRDseedV1 *ptrTracklet = NULL;
// skip Kalman filter for HLT
if(/*fkReconstructor->IsHLT()*/kFALSE){
for (Int_t jLayer = 0; jLayer < AliTRDgeometry::kNlayer; jLayer++) {
track.UnsetTracklet(jLayer);
- ptrTracklet = &seeds[jLayer];
+ ptrTracklet = &tracklet[jLayer];
if(!ptrTracklet->IsOK()) continue;
if(TMath::Abs(ptrTracklet->GetYref(1) - ptrTracklet->GetYfit(1)) >= .2) continue; // check this condition with Marian
ptrTracklet = SetTracklet(ptrTracklet);
}
// prevent the error message in AliTracker::MeanMaterialBudget: "start point out of geometry"
- if(TMath::Abs(track.GetX()) + TMath::Abs(track.GetY()) + TMath::Abs(track.GetZ()) > 10000)
- return NULL;
+ if(TMath::Abs(track.GetX()) + TMath::Abs(track.GetY()) + TMath::Abs(track.GetZ()) > 10000) return NULL;
track.ResetCovariance(1);
Int_t nc = TMath::Abs(FollowBackProlongation(track));
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 5 && fkReconstructor->IsDebugStreaming()){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) > 5 && fkReconstructor->IsDebugStreaming()){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
Double_t p[5]; // Track Params for the Debug Stream
- track.GetExternalParameters(params[0], p);
+ track.GetExternalParameters(x, p);
TTreeSRedirector &cs = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
cs << "MakeTrack"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
<< "nc=" << nc
- << "X=" << params[0]
+ << "X=" << x
<< "Y=" << p[0]
<< "Z=" << p[1]
<< "snp=" << p[2]
<< "tnd=" << p[3]
<< "crv=" << p[4]
- << "Yin=" << params[1]
- << "Zin=" << params[2]
- << "snpin=" << params[3]
- << "tndin=" << params[4]
- << "crvin=" << params[5]
+ << "Yin=" << params[0]
+ << "Zin=" << params[1]
+ << "snpin=" << params[2]
+ << "tndin=" << params[3]
+ << "crvin=" << params[4]
<< "track.=" << &track
<< "\n";
}
- if (nc < 30) return NULL;
-
+ if (nc < 30){
+ UnsetTrackletsTrack(&track);
+ return NULL;
+ }
AliTRDtrackV1 *ptrTrack = SetTrack(&track);
ptrTrack->SetReconstructor(fkReconstructor);
ptrTrack->CookLabel(.9);
-
+ for(Int_t il(kNPlanes); il--;){
+ if(!(ptrTracklet = ptrTrack->GetTracklet(il))) continue;
+ ptrTracklet->UseClusters();
+ }
+
// computes PID for track
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;
}
//____________________________________________________________________
-Int_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDseedV1 *cseed)
+Bool_t AliTRDtrackerV1::ImproveSeedQuality(AliTRDtrackingChamber **stack, AliTRDseedV1 *cseed, Double_t &chi2)
{
//
// Sort tracklets according to "quality" and try to "improve" the first 4 worst
AliTRDtrackingChamber *chamber = NULL;
AliTRDseedV1 bseed[AliTRDgeometry::kNlayer];
- Float_t quality(0.),
- lQuality[] = {1.e3, 1.e3, 1.e3, 1.e3, 1.e3, 1.e3};
+ Float_t quality(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];
}
- Float_t chi2 = FitTiltedRieman(bseed, kTRUE);
+ 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++) {
- AliDebug(2, Form("Iter[%d] Q[%f] chi2[%f]", iter, quality, chi2));
-
// 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);
}
if(rLayers > nLayers){
AliDebug(1, Form("Lost %d tracklets while improving.", rLayers-nLayers));
- break;
+ return iter>0?kTRUE:kFALSE;
} else rLayers=nLayers;
+ qualitynew /= rLayers;
- if(qualitynew >= quality){
- AliDebug(4, Form("Quality worsen in iter[%d].", iter));
- break;
+ if(qualitynew > quality){
+ AliDebug(4, Form("Quality[%f] worsen in iter[%d] to ref[%f].", qualitynew, iter, quality));
+ return iter>0?kTRUE:kFALSE;
} else quality = qualitynew;
// try improve track parameters
- AliTRDseedV1 tseed[AliTRDgeometry::kNlayer];
- for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) tseed[jLayer]=bseed[jLayer];
- Float_t chi2new = FitTiltedRieman(tseed, kTRUE);
+ Float_t chi2new = FitTiltedRieman(bseed, kTRUE);
if(chi2new > chi2){
- AliDebug(4, Form("Chi2 worsen in iter[%d].", iter));
- break;
+ AliDebug(4, Form("Chi2[%f] worsen in iter[%d] to ref[%f].", chi2new, iter, chi2));
+ return iter>0?kTRUE:kFALSE;
} else chi2 = chi2new;
// store better tracklets
- for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) bseed[jLayer]=tseed[jLayer];
+ for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) cseed[jLayer]=bseed[jLayer];
+ AliDebug(2, Form("Iter[%d] Q[%f] chi2[%f]", iter, quality, chi2));
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 7 && fkReconstructor->IsDebugStreaming()){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) >= 7 && fkReconstructor->IsDebugStreaming()){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
<< "Iteration=" << iter
- << "S0.=" << &bseed[0]
- << "S1.=" << &bseed[1]
- << "S2.=" << &bseed[2]
- << "S3.=" << &bseed[3]
- << "S4.=" << &bseed[4]
- << "S5.=" << &bseed[5]
+ << "S0.=" << &cseed[0]
+ << "S1.=" << &cseed[1]
+ << "S2.=" << &cseed[2]
+ << "S3.=" << &cseed[3]
+ << "S4.=" << &cseed[4]
+ << "S5.=" << &cseed[5]
<< "FitterT.=" << tiltedRieman
<< "\n";
}
} // Loop: iter
- // we are sure that at least 2 tracklets are OK !
- return rLayers;
+
+ // we are sure that at least 4 tracklets are OK !
+ return kTRUE;
}
//_________________________________________________________________________
-Double_t AliTRDtrackerV1::CalculateTrackLikelihood(const AliTRDseedV1 *const tracklets, Double_t *chi2){
+Double_t AliTRDtrackerV1::CalculateTrackLikelihood(Double_t *chi2){
//
// Calculates the Track Likelihood value. This parameter serves as main quality criterion for
// the track selection
//
// debug level 2
//
-
- Double_t chi2phi = 0, nLayers = 0;
- for (Int_t iLayer = 0; iLayer < kNPlanes; iLayer++) {
- if(!tracklets[iLayer].IsOK()) continue;
- chi2phi += tracklets[iLayer].GetChi2Phi();
- nLayers++;
- }
- chi2phi /= Float_t (nLayers - 2.0);
- Double_t likeChi2Z = TMath::Exp(-chi2[2] * 0.14); // Chi2Z
- Double_t likeChi2TC = (fkReconstructor->GetRecoParam()->IsVertexConstrained()) ?
- TMath::Exp(-chi2[1] * 0.677) : 1; // Constrained Tilted Riemann
- Double_t likeChi2TR = TMath::Exp(-chi2[0] * 0.0078); // Non-constrained Tilted Riemann
- Double_t likeChi2Phi= TMath::Exp(-chi2phi * 3.23);//3.23
- Double_t trackLikelihood = likeChi2Z * likeChi2TR * likeChi2Phi;
-
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+ // Non-constrained Tilted Riemann
+ Double_t likeChi2TR = TMath::Exp(-chi2[0] * 0.0078);
+ // Constrained Tilted Riemann
+ Double_t likeChi2TC(1.);
+ if(chi2[1]>0.){
+ likeChi2TC = TMath::Exp(-chi2[1] * 0.677);
+ Double_t r = likeChi2TC/likeChi2TR;
+ if(r>1.e2){;} // -> a primary track use TC
+ else if(r<1.e2) // -> a secondary track use TR
+ likeChi2TC =1.;
+ else{;} // -> test not conclusive
+ }
+ // Chi2 only on Z direction
+ Double_t likeChi2Z = TMath::Exp(-chi2[2] * 0.14);
+ // Chi2 angular resolution
+ Double_t likeChi2Phi= TMath::Exp(-chi2[3] * 3.23);
+
+ Double_t trackLikelihood = likeChi2Z * likeChi2TR * likeChi2TC * likeChi2Phi;
+
+ AliDebug(2, Form("Likelihood [%e]\n"
+ " Rieman : chi2[%f] likelihood[%6.2e]\n"
+ " Vertex : chi2[%f] likelihood[%6.2e]\n"
+ " Z : chi2[%f] likelihood[%6.2e]\n"
+ " Phi : chi2[%f] likelihood[%6.2e]"
+ , trackLikelihood
+ , chi2[0], likeChi2TR
+ , chi2[1], likeChi2TC
+ , chi2[2], likeChi2Z
+ , chi2[3], likeChi2Phi
+ ));
+
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
//
// ratio of the total number of clusters/track which are expected to be found by the tracker.
- const AliTRDrecoParam *fRecoPars = fkReconstructor->GetRecoParam();
-
Double_t chi2y = GetChi2Y(&cseed[0]);
Double_t chi2z = GetChi2Z(&cseed[0]);
}
nclusters *= .25;
- Double_t likea = TMath::Exp(-sumda * fRecoPars->GetPhiSlope());
+ Double_t likea = TMath::Exp(-sumda * fkRecoParam->GetPhiSlope());
Double_t likechi2y = 0.0000000001;
- if (fkReconstructor->IsCosmic() || chi2y < fRecoPars->GetChi2YCut()) likechi2y += TMath::Exp(-TMath::Sqrt(chi2y) * fRecoPars->GetChi2YSlope());
- Double_t likechi2z = TMath::Exp(-chi2z * fRecoPars->GetChi2ZSlope());
- Double_t likeN = TMath::Exp(-(fRecoPars->GetNMeanClusters() - nclusters) / fRecoPars->GetNSigmaClusters());
+ if (fkReconstructor->IsCosmic() || chi2y < fkRecoParam->GetChi2YCut()) likechi2y += TMath::Exp(-TMath::Sqrt(chi2y) * fkRecoParam->GetChi2YSlope());
+ Double_t likechi2z = TMath::Exp(-chi2z * fkRecoParam->GetChi2ZSlope());
+ Double_t likeN = TMath::Exp(-(fkRecoParam->GetNMeanClusters() - nclusters) / fkRecoParam->GetNSigmaClusters());
Double_t like = likea * likechi2y * likechi2z * likeN;
- if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+ if(fkRecoParam->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
Int_t nTracklets = 0; Float_t meanNcls = 0;
return n ? chi2/n : 0.;
}
+//_____________________________________________________________________________
+Float_t AliTRDtrackerV1::GetChi2Phi(const AliTRDseedV1 *const tracklets) const
+{
+ // Calculates normalized chi2 for angular resolution
+ // chi2 = Sum chi2 / n_tracklets
+
+ Double_t chi2 = 0; Int_t n = 0;
+ for (Int_t iLayer = 0; iLayer < kNPlanes; iLayer++) {
+ if(!tracklets[iLayer].IsOK()) continue;
+ chi2 += tracklets[iLayer].GetChi2Phi();
+ n++;
+ }
+ return n ? chi2/n: 0.;
+}
+
//____________________________________________________________________
Float_t AliTRDtrackerV1::CalculateReferenceX(const AliTRDseedV1 *const tracklets){
//
return chi2;
}
+//____________________________________________________________________
+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;
+ delete (fTracklets->RemoveAt(idx));
+ }
+}
+
+
///////////////////////////////////////////////////////
// //
// Resources of class AliTRDLeastSquare //
//
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
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff