#include "AliTRDrecoParam.h"
#include "AliTRDcluster.h"
+#include "AliTRDdigitsParam.h"
#include "AliTRDseedV1.h"
#include "AliTRDtrackV1.h"
#include "AliTRDtrackerV1.h"
#include "AliTRDchamberTimeBin.h"
ClassImp(AliTRDtrackerV1)
+ClassImp(AliTRDtrackerV1::AliTRDLeastSquare)
+ClassImp(AliTRDtrackerV1::AliTRDtrackFitterRieman)
const Float_t AliTRDtrackerV1::fgkMinClustersInTrack = 0.5; //
const Float_t AliTRDtrackerV1::fgkLabelFraction = 0.8; //
,fClusters(NULL)
,fTracklets(NULL)
,fTracks(NULL)
+ ,fTracksESD(NULL)
,fSieveSeeding(0)
{
//
fR[ily] = glb[0]+ AliTRDgeometry::AnodePos()-.5*AliTRDgeometry::AmThick() - AliTRDgeometry::DrThick();
}
- // initialize calibration values
- AliTRDcalibDB *trd = NULL;
- if (!(trd = AliTRDcalibDB::Instance())) {
- AliFatal("Could not get calibration.");
- }
- if(!fgNTimeBins) fgNTimeBins = trd->GetNumberOfTimeBins();
-
// initialize cluster containers
for (Int_t isector = 0; isector < AliTRDgeometry::kNsector; isector++) new(&fTrSec[isector]) AliTRDtrackingSector(fGeom, isector);
memset(fTrackQuality, 0, kMaxTracksStack*sizeof(Double_t));
memset(fSeedLayer, 0, kMaxTracksStack*sizeof(Int_t));
memset(fSeedTB, 0, kNSeedPlanes*sizeof(AliTRDchamberTimeBin*));
+ fTracksESD = new TClonesArray("AliESDtrack", 2*kMaxTracksStack);
+ fTracksESD->SetOwner();
}
//____________________________________________________________________
if(fgTiltedRieman) delete fgTiltedRieman; fgTiltedRieman = NULL;
if(fgTiltedRiemanConstrained) delete fgTiltedRiemanConstrained; fgTiltedRiemanConstrained = NULL;
for(Int_t isl =0; isl<kNSeedPlanes; isl++) if(fSeedTB[isl]) delete fSeedTB[isl];
+ if(fTracksESD){ fTracksESD->Delete(); delete fTracksESD; }
if(fTracks) {fTracks->Delete(); delete fTracks;}
if(fTracklets) {fTracklets->Delete(); delete fTracklets;}
if(fClusters) {
//AliInfo(Form("Processing supermodule %i ...", ism));
ntracks += Clusters2TracksSM(ism, esd);
}
- AliInfo(Form("Number of found tracks : %d", ntracks));
+ AliInfo(Form("Number of tracks: !TRDin[%d]", ntracks));
return ntracks;
}
// 5. Propagation to TOF. If track propagation fails the AliESDtrack::kTRDStop is set.
//
+ if(!fClusters || !fClusters->GetEntriesFast()){
+ AliInfo("No TRD clusters");
+ return 0;
+ }
AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance(); // Calibration monitor
- if (!calibra) AliInfo("Could not get Calibra instance\n");
-
+ if (!calibra) AliInfo("Could not get Calibra instance");
+ if(!fgNTimeBins) CookNTimeBins();
+
// Define scalers
Int_t nFound = 0, // number of tracks found
nSeeds = 0, // total number of ESD seeds
// update calibration references using this track
if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(&track);
// save calibration object
- if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
+ if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(track);
calibTrack->SetOwner();
seed->AddCalibObject(calibTrack);
}
//update ESD track
- if ((track.GetNumberOfClusters() > 15) && (track.GetNumberOfClusters() > 0.5*expectedClr)) {
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
- track.UpdateESDtrack(seed);
- }
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
+ track.UpdateESDtrack(seed);
}
if ((TMath::Abs(track.GetC(track.GetBz()) - p4) / TMath::Abs(p4) < 0.2) ||(track.Pt() > 0.8)) {
seed->UpdateTrackParams(&track, AliESDtrack::kTRDStop);
continue;
}
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
+ //seed->UpdateTrackParams(&track, AliESDtrack::kTRDout);
// TODO obsolete - delete
seed->SetTRDQuality(track.StatusForTOF());
}
Int_t found = 0; // contor for updated TRD tracks
+ if(!fClusters || !fClusters->GetEntriesFast()){
+ AliInfo("No TRD clusters");
+ return 0;
+ }
AliTRDtrackV1 track;
for (Int_t itrack = 0; itrack < event->GetNumberOfTracks(); itrack++) {
AliESDtrack *seed = event->GetTrack(itrack);
- new(&track) AliTRDtrackV1(*seed);
+ ULong_t status = seed->GetStatus();
+ 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
- ULong_t status = seed->GetStatus();
if(!(status & AliESDtrack::kTRDout)) continue;
if(!(status & AliESDtrack::kTRDin)) continue;
nseed++;
}
// Update the friend track
- if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
+ if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
TObject *o = NULL; Int_t ic = 0;
AliTRDtrackV1 *calibTrack = NULL;
while((o = seed->GetCalibObject(ic++))){
if (PropagateToX(tt, xTPC, fgkMaxStep)) seed->UpdateTrackParams(&tt, AliESDtrack::kTRDbackup);
}
}
- AliInfo(Form("Number of loaded seeds: %d",nseed));
- AliInfo(Form("Number of found tracks from loaded seeds: %d",found));
+ AliInfo(Form("Number of seeds: TRDout[%d]", nseed));
+ AliInfo(Form("Number of tracks: TRDrefit[%d]", found));
return 0;
}
Bool_t kStoreIn = kTRUE;
Int_t nClustersExpected = 0;
for (Int_t iplane = kNPlanes; iplane--;) {
- Int_t index = 0;
+ Int_t index(-1);
AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
+ AliDebug(2, Form("Tracklet[%p] ly[%d] idx[%d]", (void*)tracklet, iplane, index));
if(!tracklet) continue;
- if(!tracklet->IsOK()) AliWarning("tracklet not OK");
-
+ if(!tracklet->IsOK()){
+ AliDebug(1, Form("Tracklet Det[%d] !OK", tracklet->GetDetector()));
+ continue;
+ }
Double_t x = tracklet->GetX();//GetX0();
// reject tracklets which are not considered for inward refit
if(x > t.GetX()+fgkMaxStep) continue;
}
}
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+ if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 1){
Int_t index;
for(int iplane=0; iplane<AliTRDgeometry::kNlayer; iplane++){
AliTRDseedV1 *tracklet = GetTracklet(&t, iplane, index);
t.SetTracklet(tracklet, index);
}
- Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
- AliTRDtrackV1 track(t);
- track.SetOwner();
- cstreamer << "FollowProlongation"
- << "EventNumber=" << eventNumber
- << "ncl=" << nClustersExpected
- << "track.=" << &track
- << "\n";
+ if(fkReconstructor->IsDebugStreaming()){
+ Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
+ AliTRDtrackV1 track(t);
+ track.SetOwner();
+ cstreamer << "FollowProlongation"
+ << "EventNumber=" << eventNumber
+ << "ncl=" << nClustersExpected
+ << "track.=" << &track
+ << "\n";
+ }
}
-
return nClustersExpected;
}
Double_t driftLength = .5*AliTRDgeometry::AmThick() + AliTRDgeometry::DrThick();
AliTRDtrackingChamber *chamber = NULL;
+ Int_t debugLevel = fkReconstructor->IsDebugStreaming() ? fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) : 0;
+ TTreeSRedirector *cstreamer = fkReconstructor->IsDebugStreaming() ? fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker) : 0x0;
+
AliTRDseedV1 tracklet, *ptrTracklet = NULL;
// in case of stand alone tracking we store all the pointers to the tracklets in a temporary array
AliTRDseedV1 *tracklets[kNPlanes];
TGeoHMatrix *matrix = NULL;
Double_t x, y, z;
for (Int_t ily=0, 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);
+ 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) ||
stk<0. ||
fGeom->IsHole(ily, stk, 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);
+ AliDebug(4, "Failed Propagation [Missing Geometry]");
break;
}
if(!AdjustSector(&t)){
n=-1;
t.SetStatus(AliTRDtrackV1::kAdjustSector);
+ AliDebug(4, "Failed Adjust Sector [Missing Geometry]");
break;
}
if(TMath::Abs(t.GetSnp()) > fgkMaxSnp){
n=-1;
t.SetStatus(AliTRDtrackV1::kSnp);
+ AliDebug(4, "Failed Max Snp [Missing Geometry]");
break;
}
t.SetStatus(AliTRDtrackV1::kGeometry, ily);
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));
break;
}
if(!AdjustSector(&t)){
n=-1;
t.SetStatus(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));
break;
}
Bool_t doRecalculate = kFALSE;
det = AliTRDgeometry::GetDetector(ily, stk, sm);
if(!(matrix = fGeom->GetClusterMatrix(det))){
t.SetStatus(AliTRDtrackV1::kGeometry, ily);
+ AliDebug(4, Form("Failed Geometry Matrix ly[%d]", ily));
continue;
}
matrix->LocalToMaster(loc, glb);
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));
break;
}
if(fGeom->IsOnBoundary(det, y, z, .5)){
t.SetStatus(AliTRDtrackV1::kBoundary, ily);
+ AliDebug(4, "Failed Track on Boundary");
continue;
}
// mark track as entering the FIDUCIAL volume of TRD
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);
+ AliDebug(4, "Failed NoClusters");
continue;
}
if(fTrSec[sm].GetX(ily) < 1.){
t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+ AliDebug(4, "Failed NoX");
continue;
}
// check data in chamber
if(!(chamber = fTrSec[sm].GetChamber(stk, ily))){
t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+ AliDebug(4, "Failed No Detector");
continue;
}
if(chamber->GetNClusters() < fgNTimeBins*fkReconstructor->GetRecoParam() ->GetFindableClusters()){
t.SetStatus(AliTRDtrackV1::kNoClusters, ily);
+ AliDebug(4, "Failed Not Enough Clusters in Detector");
continue;
}
// build tracklet
if(!tracklet.Init(&t)){
n=-1;
t.SetStatus(AliTRDtrackV1::kTrackletInit);
+ AliDebug(4, "Failed Tracklet Init");
break;
}
if(!tracklet.AttachClusters(chamber, kTRUE)){
t.SetStatus(AliTRDtrackV1::kNoAttach, ily);
+ if(debugLevel>3){
+ AliTRDseedV1 trackletCp(*ptrTracklet);
+ UChar_t status(t.GetStatusTRD(ily));
+ (*cstreamer) << "FollowBackProlongation2"
+ <<"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);
+ if(debugLevel>3){
+ AliTRDseedV1 trackletCp(*ptrTracklet);
+ UChar_t status(t.GetStatusTRD(ily));
+ (*cstreamer) << "FollowBackProlongation2"
+ <<"status=" << status
+ <<"tracklet.=" << &trackletCp
+ << "\n";
+ }
+ AliDebug(4, "Failed N Clusters Attached");
continue;
}
ptrTracklet->UpdateUsed();
- }
+ } 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);
+ 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);
+ AliDebug(4, Form("Failed Propagation to Tracklet x[%7.2f]", x));
break;
}
if(!AdjustSector(&t)) {
n=-1;
t.SetStatus(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));
break;
}
if(kPropagateIn){
Double_t cov[3]; ptrTracklet->GetCovAt(x, cov);
Double_t p[2] = { ptrTracklet->GetY(), ptrTracklet->GetZ()};
Double_t chi2 = ((AliExternalTrackParam)t).GetPredictedChi2(p, cov);
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
- Double_t ytrack = ptrTracklet->GetYref(0);
- Double_t ztrack = ptrTracklet->GetZref(0);
- Double_t ytracklet = ptrTracklet->GetYfit(0);
- Double_t ztracklet = ptrTracklet->GetZfit(0);
- Double_t phitrack = ptrTracklet->GetYref(1);
- Double_t phitracklet = ptrTracklet->GetYfit(1);
- Double_t thetatrack = ptrTracklet->GetZref(1);
- Double_t thetatracklet = ptrTracklet->GetZfit(1);
-
- TTreeSRedirector &mystreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
- mystreamer << "FollowBackProlongation1"
- << "il=" << ily
- << "x=" << x
- << "ytrack=" << ytrack
- << "ztrack=" << ztrack
- << "ytracklet=" << ytracklet
- << "ztracklet=" << ztracklet
- << "phitrack=" << phitrack
- << "thetatrack=" << thetatrack
- << "phitracklet=" << phitracklet
- << "thetatracklet=" << thetatracklet
- << "chi2=" << chi2
- << "\n";
- }
// update Kalman with the TRD measurement
if(chi2>1e+10){ // TODO
t.SetStatus(AliTRDtrackV1::kChi2, ily);
+ 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";
+ }
+ 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";
+ }
+ 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;
}
// fill residuals ?!
// load tracklet to the tracker
ptrTracklet->Update(&t);
ptrTracklet = SetTracklet(ptrTracklet);
- t.SetTracklet(ptrTracklet, fTracklets->GetEntriesFast()-1);
+ Int_t index(fTracklets->GetEntriesFast()-1);
+ t.SetTracklet(ptrTracklet, index);
n += ptrTracklet->GetN();
+ AliDebug(2, Form("Setting Tracklet[%d] @ Idx[%d]", ily, index));
// Reset material budget if 2 consecutive gold
// if(ilayer>0 && t.GetTracklet(ilayer-1) && ptrTracklet->GetN() + t.GetTracklet(ilayer-1)->GetN() > 20) t.SetBudget(2, 0.);
//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(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ if(debugLevel > 1){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
AliTRDtrackV1 track(t);
track.SetOwner();
- cstreamer << "FollowBackProlongation"
+ (*cstreamer) << "FollowBackProlongation0"
<< "EventNumber=" << eventNumber
<< "ncl=" << n
<< "track.=" << &track
for(Int_t ip = 0; ip < AliTRDtrackerV1::kNPlanes; ip++)
tracklets[ip].SetC(curvature);
-/* if(fkReconstructor->GetStreamLevel() >= 5){
+/* if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker()) >= 5){
//Linear Model on z-direction
Double_t xref = CalculateReferenceX(tracklets); // Relative to the middle of the stack
Double_t slope = fitter->GetParameter(2);
tracklets[iLayer].SetChi2(chi2track);
}
-/* if(fkReconstructor->GetStreamLevel() >=5){
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+/* if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >=5){
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
Double_t chi2z = CalculateChi2Z(tracklets, offset, slope, xref);
}
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));
Double_t x, y, z, t, tilt, dx, w, we;
Double_t uvt[4];
Int_t nPoints = 0;
if(!tracklets[ipl].IsOK()) continue;
for(Int_t itb = 0; itb < AliTRDseedV1::kNclusters; itb++){
if(!(cl = tracklets[ipl].GetClusters(itb))) continue;
- if (!tracklets[ipl].IsUsable(itb)) continue;
+ //if (!tracklets[ipl].IsUsable(itb)) continue;
x = cl->GetX();
y = cl->GetY();
z = cl->GetZ();
// 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));
// Update the tracklets
if(!track){
//____________________________________________________________________
-Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, const AliTRDseedV1 * const tracklets, Bool_t up, Int_t np, AliTrackPoint *points)
+Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, AliTRDseedV1 * const tracklets, Bool_t up, Int_t np, AliTrackPoint *points)
{
// Kalman filter implementation for the TRD.
// It returns the positions of the fit in the array "points"
// GET TRACKLET OR BUILT IT
Int_t iplane = up ? jplane : kNPlanes - 1 - jplane;
if(tracklets){
- if(!(ptrTracklet = const_cast<AliTRDseedV1 *>(&tracklets[iplane]))) continue;
+ if(!(ptrTracklet = &tracklets[iplane])) continue;
}else{
if(!(ptrTracklet = track->GetTracklet(iplane))){
/*AliTRDtrackerV1 *tracker = NULL;
- if(!(tracker = dynamic_cast<AliTRDtrackerV1*>( AliTRDReconstructor::Tracker()))) continue;
+ if(!(tracker = dynamic_cast<AliTRDtrackerV1*>( AliTRDrecoParam:Tracker()))) continue;
ptrTracklet = new(&tracklet) AliTRDseedV1(iplane);
if(!tracker->MakeTracklet(ptrTracklet, track)) */
continue;
xyz1[0] = x * TMath::Cos(alpha) - y * TMath::Sin(alpha);
xyz1[1] = +x * TMath::Sin(alpha) + y * TMath::Cos(alpha);
xyz1[2] = z;
- if((xyz0[0] - xyz1[9] < 1e-3) && (xyz0[0] - xyz1[9] < 1e-3)) continue; // check wheter we are at the same global x position
+ if(TMath::Abs(xyz0[0] - xyz1[0]) < 1e-3 && TMath::Abs(xyz0[1] - xyz1[1]) < 1e-3) continue; // check wheter we are at the same global x position
Double_t param[7];
if(AliTracker::MeanMaterialBudget(xyz0, xyz1, param) <=0.) break;
Double_t xrho = param[0]*param[4]; // density*length
while (icl--) {
AliTRDcluster *c = (AliTRDcluster *) fClusters->UncheckedAt(icl);
if(c->IsInChamber()) nin++;
+ if(fkReconstructor->IsHLT()) c->SetRPhiMethod(AliTRDcluster::kCOG);
Int_t detector = c->GetDetector();
Int_t sector = fGeom->GetSector(detector);
Int_t stack = fGeom->GetStack(detector);
// Detailed description
//
idx = track->GetTrackletIndex(p);
- AliTRDseedV1 *tracklet = (idx==0xffff) ? NULL : (AliTRDseedV1*)fTracklets->UncheckedAt(idx);
+ AliTRDseedV1 *tracklet = (idx<0) ? NULL : (AliTRDseedV1*)fTracklets->UncheckedAt(idx);
return tracklet;
}
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)
{
// 3. Pack results in the ESD event.
//
- // allocate space for esd tracks in this SM
- TClonesArray esdTrackList("AliESDtrack", 2*kMaxTracksStack);
- esdTrackList.SetOwner();
-
Int_t nTracks = 0;
Int_t nChambers = 0;
AliTRDtrackingChamber **stack = NULL, *chamber = NULL;
}
if(nChambers < 4) continue;
//AliInfo(Form("Doing stack %d", istack));
- nTracks += Clusters2TracksStack(stack, &esdTrackList);
+ nTracks += Clusters2TracksStack(stack, fTracksESD);
+ }
+ if(nTracks) AliDebug(2, Form("Number of tracks: SM_%02d[%d]", sector, nTracks));
+
+ for(int itrack=0; itrack<nTracks; itrack++){
+ AliESDtrack *esdTrack((AliESDtrack*)(fTracksESD->operator[](itrack)));
+ Int_t id = esd->AddTrack(esdTrack);
+
+ // set ESD id to stand alone TRD tracks
+ if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
+ esdTrack=esd->GetTrack(id);
+ TObject *o(NULL); Int_t ic(0);
+ AliTRDtrackV1 *calibTrack(NULL);
+ while((o = esdTrack->GetCalibObject(ic++))){
+ if(!(calibTrack = dynamic_cast<AliTRDtrackV1*>(o))) continue;
+ calibTrack->SetESDid(esdTrack->GetID());
+ break;
+ }
+ }
}
- //AliInfo(Form("Found %d tracks in SM %d [%d]\n", nTracks, sector, esd->GetNumberOfTracks()));
-
- for(int itrack=0; itrack<nTracks; itrack++)
- esd->AddTrack((AliESDtrack*)esdTrackList[itrack]);
// Reset Track and Candidate Number
AliTRDtrackerDebug::SetCandidateNumber(0);
AliTRDtrackerDebug::SetTrackNumber(0);
+
+ // delete ESD tracks in the array
+ fTracksESD->Delete();
return nTracks;
}
// Build initial seeding configurations
Double_t quality = BuildSeedingConfigs(stack, configs);
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
+ if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 10){
AliInfo(Form("Plane config %d %d %d Quality %f"
, configs[0], configs[1], configs[2], quality));
}
//AliInfo(Form("Number of Tracks after iteration step %d: %d\n", iconf, ntracks));
if(ntracks == kMaxTracksStack) break;
}
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1) AliInfo(Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
+ AliDebug(2, Form("Candidate TRD tracks %d in iteration %d.", ntracks, fSieveSeeding));
if(!ntracks) break;
fakeTrack[trackIndex] = kTRUE;
continue;
}
- if (Float_t(nused)/ncl >= .25){
+ if (ncl>0 && Float_t(nused)/ncl >= .25){
//printf("Skip %d nused/ncl >= .25\n", trackIndex);
fakeTrack[trackIndex] = kTRUE;
continue;
}
if(skip){
candidates++;
- //printf("REJECTED : %d [%d] nlayers %d trackQuality = %e nused %d\n", itrack, trackIndex, nlayers, fTrackQuality[trackIndex], nused);
+ 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
Int_t ich = 0; while(!(chamber = stack[ich])) ich++;
trackParams[6] = fGeom->GetSector(chamber->GetDetector());/* *alpha+shift; // Supermodule*/
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+ if(fkReconstructor->GetRecoParam()->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 eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t trackNumber = AliTRDtrackerDebug::GetTrackNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
cstreamer << "Clusters2TracksStack"
<< "EventNumber=" << eventNumber
<< "TrackNumber=" << trackNumber
AliTRDtrackV1 *track = MakeTrack(&sseed[trackIndex*kNPlanes], trackParams);
if(!track){
- AliWarning("Fail to build a TRD Track.");
+ AliDebug(1, "Track building failed.");
continue;
}
esdTrack->SetLabel(track->GetLabel());
track->UpdateESDtrack(esdTrack);
// write ESD-friends if neccessary
- if (fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
+ if (fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) > 0){
AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(*track);
calibTrack->SetOwner();
esdTrack->AddCalibObject(calibTrack);
chamber->Build(fGeom, cal);//Indices(fSieveSeeding);
}
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 10){
+ if(fkReconstructor->GetRecoParam()->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
}
//____________________________________________________________________
-Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, const AliTRDseedV1 * const sseed, const Int_t * const ipar)
+Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 * const sseed, const Int_t * const ipar)
{
//
// Seed tracklets and build candidate TRD tracks. The procedure is used during barrel tracking to account for tracks which are
AliTRDtrackingChamber *chamber = NULL;
AliTRDcluster *c[kNSeedPlanes] = {NULL, NULL, NULL, NULL}; // initilize seeding clusters
- AliTRDseedV1 *cseed = const_cast<AliTRDseedV1 *>(&sseed[0]); // initialize tracklets for first track
+ AliTRDseedV1 *cseed = &sseed[0]; // initialize tracklets for first track
Int_t ncl, mcl; // working variable for looping over clusters
Int_t index[AliTRDchamberTimeBin::kMaxClustersLayer], jndex[AliTRDchamberTimeBin::kMaxClustersLayer];
// chi2 storage
x0[iLayer] = glb[0];
}
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 2){
- AliInfo(Form("Making seeds Stack[%d] Config[%d] Tracks[%d]...", istack, config, ntracks));
- }
+ AliDebug(2, Form("Making seeds Stack[%d] Config[%d] Tracks[%d]...", istack, config, ntracks));
// Build seeding layers
ResetSeedTB();
c[2] = fSeedTB[2]->GetNearestCluster(cond2);
//printf("Found c[1] candidate 2 %p\n", c[2]);
if(!c[2]) continue;
-
- //AliInfo("Seeding clusters found. Building seeds ...");
- //for(Int_t i = 0; i < kNSeedPlanes; i++) printf("%i. coordinates: x = %6.3f, y = %6.3f, z = %6.3f\n", i, c[i]->GetX(), c[i]->GetY(), c[i]->GetZ());
+
+ AliDebug(3, Form("Seeding clusters\n 0[%6.3f %6.3f %6.3f]\n 1[%6.3f %6.3f %6.3f]\n 2[%6.3f %6.3f %6.3f]\n 3[%6.3f %6.3f %6.3f].",
+ c[0]->GetX(), c[0]->GetY(), c[0]->GetZ(),
+ c[1]->GetX(), c[1]->GetY(), c[1]->GetZ(),
+ c[2]->GetX(), c[2]->GetY(), c[2]->GetZ(),
+ c[3]->GetX(), c[3]->GetY(), c[3]->GetZ()));
for (Int_t il = 0; il < kNPlanes; il++) cseed[il].Reset();
}
Bool_t isFake = kFALSE;
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+ if(fkReconstructor->GetRecoParam()->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;
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
AliRieman *rim = GetRiemanFitter();
- TTreeSRedirector &cs0 = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cs0 = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
cs0 << "MakeSeeds0"
<<"EventNumber=" << eventNumber
<<"CandidateNumber=" << candidateNumber
<<"\n";
}
if(chi2[0] > fkReconstructor->GetRecoParam() ->GetChi2Z()/*7./(3. - sLayer)*//*iter*/){
- //AliInfo(Form("Failed chi2 filter on chi2Z [%f].", chi2[0]));
+ 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*/){
- //AliInfo(Form("Failed chi2 filter on chi2Y [%f].", chi2[1]));
+ AliDebug(3, Form("Filter on chi2Y [%f].", chi2[1]));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
// try attaching clusters to tracklets
Int_t mlayers = 0;
- AliTRDcluster *cl = NULL;
+ AliTRDcluster *cl = NULL;
for(int iLayer=0; iLayer<kNSeedPlanes; iLayer++){
Int_t jLayer = planes[iLayer];
- Int_t nNotInChamber = 0;
+ Int_t nNotInChamber = 0;
if(!cseed[jLayer].AttachClusters(stack[jLayer], kTRUE)) continue;
- if(fkReconstructor->IsHLT()){
- cseed[jLayer].UpdateUsed();
- if(!cseed[jLayer].IsOK()) continue;
- }else{
- cseed[jLayer].Fit();
- cseed[jLayer].UpdateUsed();
- cseed[jLayer].ResetClusterIter();
- while((cl = cseed[jLayer].NextCluster())){
- if(!cl->IsInChamber()) nNotInChamber++;
- }
- //printf("clusters[%d], used[%d], not in chamber[%d]\n", cseed[jLayer].GetN(), cseed[jLayer].GetNUsed(), nNotInChamber);
- if(cseed[jLayer].GetN() - (cseed[jLayer].GetNUsed() + nNotInChamber) < 5) continue; // checking for Cluster which are not in chamber is a much stronger restriction on real data
- }
+ if(/*fkReconstructor->IsHLT()*/kFALSE){
+ cseed[jLayer].UpdateUsed();
+ if(!cseed[jLayer].IsOK()) continue;
+ }else{
+ cseed[jLayer].Fit();
+ cseed[jLayer].UpdateUsed();
+ cseed[jLayer].ResetClusterIter();
+ while((cl = cseed[jLayer].NextCluster())){
+ if(!cl->IsInChamber()) nNotInChamber++;
+ }
+ //printf("clusters[%d], used[%d], not in chamber[%d]\n", cseed[jLayer].GetN(), cseed[jLayer].GetNUsed(), nNotInChamber);
+ if(cseed[jLayer].GetN() - (cseed[jLayer].GetNUsed() + nNotInChamber) < 5) continue; // checking for Cluster which are not in chamber is a much stronger restriction on real data
+ }
mlayers++;
}
if(mlayers < kNSeedPlanes){
- //AliInfo(Form("Failed updating all seeds %d [%d].", mlayers, kNSeedPlanes));
+ AliDebug(2, Form("Found only %d tracklets out of %d. Skip.", mlayers, kNSeedPlanes));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
for(int iLayer=0; iLayer<kNPlanes-kNSeedPlanes; iLayer++){
Int_t jLayer = planesExt[iLayer];
if(!(chamber = stack[jLayer])) continue;
- cseed[jLayer].AttachClusters(chamber, kTRUE);
- //cseed[jLayer].Fit();
+ if(!cseed[jLayer].AttachClusters(chamber, kTRUE)) continue;
+ cseed[jLayer].Fit();
}
fTrackQuality[ntracks] = 1.; // dummy value
ntracks++;
Double_t like = CookLikelihood(&cseed[0], planes); // to be checked
if (TMath::Log(1.E-9 + like) < fkReconstructor->GetRecoParam() ->GetTrackLikelihood()){
- //AliInfo(Form("Failed likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
+ AliDebug(3, Form("Filter on likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
fSeedLayer[ntracks] = config;/*sLayer;*/
// attach clusters to the extrapolation seeds
+ Int_t elayers(0);
for(int iLayer=0; iLayer<kNPlanes-kNSeedPlanes; iLayer++){
Int_t jLayer = planesExt[iLayer];
if(!(chamber = stack[jLayer])) continue;
cseed[jLayer] = pseed;
FitTiltedRieman(cseed, kTRUE);
cseed[jLayer].Fit(kTRUE);
+ elayers++;
}
// AliInfo("Extrapolation done.");
// Debug Stream containing all the 6 tracklets
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
<< "\n";
}
- if(fkReconstructor->HasImproveTracklets() && ImproveSeedQuality(stack, cseed) < 4){
- AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
- continue;
+ 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){
+ 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];
+ }
}
//AliInfo("Improve seed quality done.");
// 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->HasVertexConstrained())
+ if(fkReconstructor->GetRecoParam()->IsVertexConstrained())
chi2Vals[1] = FitTiltedRiemanConstraint(&cseed[0], GetZ()); // Do Vertex Constrained fit if desired
else
chi2Vals[1] = 1.;
fTrackQuality[ntracks] = CalculateTrackLikelihood(&cseed[0], &chi2Vals[0]);
//AliInfo("Hyperplane fit done\n");
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
TLinearFitter *fitterTC = GetTiltedRiemanFitterConstraint();
}
//_____________________________________________________________________________
-AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(const AliTRDseedV1 * const seeds, Double_t *params)
+AliTRDtrackV1* AliTRDtrackerV1::MakeTrack(AliTRDseedV1 * const seeds, Double_t *params)
{
//
// Build a TRD track out of tracklet candidates
AliTRDseedV1 *ptrTracklet = NULL;
// skip Kalman filter for HLT
- if(fkReconstructor->IsHLT()){
+ if(/*fkReconstructor->IsHLT()*/kFALSE){
for (Int_t jLayer = 0; jLayer < AliTRDgeometry::kNlayer; jLayer++) {
track.UnsetTracklet(jLayer);
- ptrTracklet = const_cast<AliTRDseedV1 *>(&seeds[jLayer]);
+ ptrTracklet = &seeds[jLayer];
if(!ptrTracklet->IsOK()) continue;
- //if(TMath::Abs(ptrTracklet->GetYref(1) - ptrTracklet->GetYfit(1)) >= .2) continue; // check this condition with Marian
+ if(TMath::Abs(ptrTracklet->GetYref(1) - ptrTracklet->GetYfit(1)) >= .2) continue; // check this condition with Marian
ptrTracklet = SetTracklet(ptrTracklet);
ptrTracklet->UseClusters();
track.SetTracklet(ptrTracklet, fTracklets->GetEntriesFast()-1);
}
AliTRDtrackV1 *ptrTrack = SetTrack(&track);
ptrTrack->CookPID();
+ ptrTrack->CookLabel(.9);
ptrTrack->SetReconstructor(fkReconstructor);
return ptrTrack;
}
+ // 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;
+
track.ResetCovariance(1);
Int_t nc = TMath::Abs(FollowBackProlongation(track));
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 5){
+ if(fkReconstructor->GetRecoParam()->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);
- TTreeSRedirector &cs = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cs = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
cs << "MakeTrack"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
// make a local working copy
AliTRDtrackingChamber *chamber = NULL;
- AliTRDseedV1 bseed[6];
- Int_t nLayers = 0;
- for (Int_t jLayer = 0; jLayer < 6; jLayer++) bseed[jLayer] = cseed[jLayer];
-
- Float_t lastquality = 10000.0;
- Float_t lastchi2 = 10000.0;
- Float_t chi2 = 1000.0;
+ AliTRDseedV1 bseed[AliTRDgeometry::kNlayer];
+
+ Float_t quality(0.),
+ lQuality[] = {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];
+ if(!bseed[jLayer].IsOK()) continue;
+ rLayers++;
+ lQuality[jLayer] = bseed[jLayer].GetQuality(kTRUE);
+ quality += lQuality[jLayer];
+ }
+ Float_t chi2 = FitTiltedRieman(bseed, kTRUE);
for (Int_t iter = 0; iter < 4; iter++) {
- Float_t sumquality = 0.0;
- Float_t squality[6];
- Int_t sortindexes[6];
-
- for (Int_t jLayer = 0; jLayer < 6; jLayer++) {
- squality[jLayer] = bseed[jLayer].IsOK() ? bseed[jLayer].GetQuality(kTRUE) : 1000.;
- sumquality += squality[jLayer];
- }
- if ((sumquality >= lastquality) || (chi2 > lastchi2)) break;
-
- nLayers = 0;
- lastquality = sumquality;
- lastchi2 = chi2;
- if (iter > 0) for (Int_t jLayer = 0; jLayer < 6; jLayer++) cseed[jLayer] = bseed[jLayer];
-
- TMath::Sort(6, squality, sortindexes, kFALSE);
- for (Int_t jLayer = 5; jLayer > 1; jLayer--) {
- Int_t bLayer = sortindexes[jLayer];
+ 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];
+ 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;
- bseed[bLayer].AttachClusters(chamber, kTRUE);
+ if(!bseed[bLayer].AttachClusters(chamber, kTRUE)) continue;
bseed[bLayer].Fit(kTRUE);
- if(bseed[bLayer].IsOK()) nLayers++;
+ if(!bseed[bLayer].IsOK()) continue;
+ nLayers++;
+ lQuality[jLayer] = bseed[jLayer].GetQuality(kTRUE);
+ qualitynew += lQuality[jLayer];
}
+ if(rLayers > nLayers){
+ AliDebug(1, Form("Lost %d tracklets while improving.", rLayers-nLayers));
+ break;
+ } else rLayers=nLayers;
- chi2 = FitTiltedRieman(bseed, kTRUE);
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 7){
+ if(qualitynew >= quality){
+ AliDebug(4, Form("Quality worsen in iter[%d].", iter));
+ break;
+ } 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);
+ if(chi2new > chi2){
+ AliDebug(4, Form("Chi2 worsen in iter[%d].", iter));
+ break;
+ } else chi2 = chi2new;
+
+ // store better tracklets
+ for(Int_t jLayer=AliTRDgeometry::kNlayer; jLayer--;) bseed[jLayer]=tseed[jLayer];
+
+
+ if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 7 && fkReconstructor->IsDebugStreaming()){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
TLinearFitter *tiltedRieman = GetTiltedRiemanFitter();
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
cstreamer << "ImproveSeedQuality"
- << "EventNumber=" << eventNumber
- << "CandidateNumber=" << candidateNumber
- << "Iteration=" << iter
- << "S0.=" << &bseed[0]
- << "S1.=" << &bseed[1]
- << "S2.=" << &bseed[2]
- << "S3.=" << &bseed[3]
- << "S4.=" << &bseed[4]
- << "S5.=" << &bseed[5]
- << "FitterT.=" << tiltedRieman
- << "\n";
+ << "EventNumber=" << eventNumber
+ << "CandidateNumber=" << candidateNumber
+ << "Iteration=" << iter
+ << "S0.=" << &bseed[0]
+ << "S1.=" << &bseed[1]
+ << "S2.=" << &bseed[2]
+ << "S3.=" << &bseed[3]
+ << "S4.=" << &bseed[4]
+ << "S5.=" << &bseed[5]
+ << "FitterT.=" << tiltedRieman
+ << "\n";
}
} // Loop: iter
// we are sure that at least 2 tracklets are OK !
- return nLayers+2;
+ return rLayers;
}
//_________________________________________________________________________
chi2phi /= Float_t (nLayers - 2.0);
Double_t likeChi2Z = TMath::Exp(-chi2[2] * 0.14); // Chi2Z
- Double_t likeChi2TC = (fkReconstructor->HasVertexConstrained()) ?
+ 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->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+ if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
cstreamer << "CalculateTrackLikelihood0"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
Double_t likeN = TMath::Exp(-(fRecoPars->GetNMeanClusters() - nclusters) / fRecoPars->GetNSigmaClusters());
Double_t like = likea * likechi2y * likechi2z * likeN;
- if(fkReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) >= 2){
+ if(fkReconstructor->GetRecoParam()->GetStreamLevel(AliTRDrecoParam::kTracker) >= 2 && fkReconstructor->IsDebugStreaming()){
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
Int_t candidateNumber = AliTRDtrackerDebug::GetCandidateNumber();
Int_t nTracklets = 0; Float_t meanNcls = 0;
}
if(nTracklets) meanNcls /= nTracklets;
// The Debug Stream contains the seed
- TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDReconstructor::kTracker);
+ TTreeSRedirector &cstreamer = *fkReconstructor->GetDebugStream(AliTRDrecoParam::kTracker);
cstreamer << "CookLikelihood"
<< "EventNumber=" << eventNumber
<< "CandidateNumber=" << candidateNumber
//____________________________________________________________________
AliCluster* AliTRDtrackerV1::GetCluster(Int_t idx) const
{
+ if(!fClusters) return NULL;
Int_t ncls = fClusters->GetEntriesFast();
return idx >= 0 && idx < ncls ? (AliCluster*)fClusters->UncheckedAt(idx) : NULL;
}
//____________________________________________________________________
AliTRDseedV1* AliTRDtrackerV1::GetTracklet(Int_t idx) const
{
+ if(!fTracklets) return NULL;
Int_t ntrklt = fTracklets->GetEntriesFast();
return idx >= 0 && idx < ntrklt ? (AliTRDseedV1*)fTracklets->UncheckedAt(idx) : NULL;
}
//____________________________________________________________________
AliKalmanTrack* AliTRDtrackerV1::GetTrack(Int_t idx) const
{
+ if(!fTracks) return NULL;
Int_t ntrk = fTracks->GetEntriesFast();
return idx >= 0 && idx < ntrk ? (AliKalmanTrack*)fTracks->UncheckedAt(idx) : NULL;
}
//_____________________________________________________________________________
AliTRDtrackerV1::AliTRDLeastSquare::AliTRDLeastSquare(){
- //
- // Constructor of the nested class AliTRDtrackFitterLeastSquare
- //
+//
+// Constructor of the nested class AliTRDtrackFitterLeastSquare
+//
+// Fast solving linear regresion in 2D
+// y=a + bx
+// The data members have the following meaning
+// fParams[0] : a
+// fParams[1] : b
+//
+// fSums[0] : S
+// fSums[1] : Sx
+// fSums[2] : Sy
+// fSums[3] : Sxy
+// fSums[4] : Sxx
+// fSums[5] : Syy
+//
+// fCovarianceMatrix[0] : s2a
+// fCovarianceMatrix[1] : s2b
+// fCovarianceMatrix[2] : cov(ab)
+
memset(fParams, 0, sizeof(Double_t) * 2);
memset(fSums, 0, sizeof(Double_t) * 6);
memset(fCovarianceMatrix, 0, sizeof(Double_t) * 3);
//
// Adding Point to the fitter
//
+
Double_t weight = 1/(sigmaY > 1e-9 ? sigmaY : 1e-9);
weight *= weight;
const Double_t &xpt = *x;
//
// Remove Point from the sample
//
-
+
Double_t weight = 1/(sigmaY > 1e-9 ? sigmaY : 1e-9);
weight *= weight;
const Double_t &xpt = *x;
}
//_____________________________________________________________________________
-void AliTRDtrackerV1::AliTRDLeastSquare::Eval(){
+Bool_t AliTRDtrackerV1::AliTRDLeastSquare::Eval(){
//
// Evaluation of the fit:
// Calculation of the parameters
// Calculation of the covariance matrix
//
- Double_t denominator = fSums[0] * fSums[4] - fSums[1] *fSums[1];
- if(denominator==0) return;
+ Double_t det = fSums[0] * fSums[4] - fSums[1] *fSums[1];
+ if(det==0) return kFALSE;
// for(Int_t isum = 0; isum < 5; isum++)
// printf("fSums[%d] = %f\n", isum, fSums[isum]);
// printf("denominator = %f\n", denominator);
- fParams[0] = (fSums[2] * fSums[4] - fSums[1] * fSums[3])/ denominator;
- fParams[1] = (fSums[0] * fSums[3] - fSums[1] * fSums[2]) / denominator;
+ fParams[0] = (fSums[2] * fSums[4] - fSums[1] * fSums[3])/det;
+ fParams[1] = (fSums[0] * fSums[3] - fSums[1] * fSums[2])/det;
// printf("fParams[0] = %f, fParams[1] = %f\n", fParams[0], fParams[1]);
// Covariance matrix
- fCovarianceMatrix[0] = fSums[4] / fSums[0] - fSums[1] * fSums[1] / (fSums[0] * fSums[0]);
+ Double_t den = fSums[0]*fSums[4] - fSums[1]*fSums[1];
+ fCovarianceMatrix[0] = fSums[4] / den;
+ fCovarianceMatrix[1] = fSums[0] / den;
+ fCovarianceMatrix[2] = -fSums[1] / den;
+/* fCovarianceMatrix[0] = fSums[4] / fSums[0] - fSums[1] * fSums[1] / (fSums[0] * fSums[0]);
fCovarianceMatrix[1] = fSums[5] / fSums[0] - fSums[2] * fSums[2] / (fSums[0] * fSums[0]);
- fCovarianceMatrix[2] = fSums[3] / fSums[0] - fSums[1] * fSums[2] / (fSums[0] * fSums[0]);
+ fCovarianceMatrix[2] = fSums[3] / fSums[0] - fSums[1] * fSums[2] / (fSums[0] * fSums[0]);*/
+
+
+
+ return kTRUE;
}
//_____________________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff