//____________________________________________________________________
AliTRDtrackerV1::AliTRDtrackerV1(AliTRDReconstructor *rec)
:AliTracker()
- ,fReconstructor(rec)
+ ,fReconstructor(0x0)
,fGeom(new AliTRDgeometry())
,fClusters(0x0)
,fTracklets(0x0)
for(Int_t isl =0; isl<kNSeedPlanes; isl++) fSeedTB[isl] = 0x0;
// Initialize debug stream
- if(fReconstructor){
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
- TDirectory *savedir = gDirectory;
- fgDebugStreamer = new TTreeSRedirector("TRD.TrackerDebug.root");
- savedir->cd();
- }
- }
+ if(rec) SetReconstructor(rec);
}
//____________________________________________________________________
for(Int_t isl =0; isl<kNSeedPlanes; isl++) if(fSeedTB[isl]) delete fSeedTB[isl];
if(fTracks) {fTracks->Delete(); delete fTracks;}
if(fTracklets) {fTracklets->Delete(); delete fTracklets;}
- if(fClusters) {fClusters->Delete(); delete fClusters;}
+ if(fClusters) {
+ fClusters->Delete(); delete fClusters;
+ }
if(fGeom) delete fGeom;
}
//track->Print();
//Int_t lbl = seed->GetLabel();
//track.SetSeedLabel(lbl);
- seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup); // Make backup
+
+ // Make backup and mark entrance in the TRD
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDin);
+ seed->UpdateTrackParams(&track, AliESDtrack::kTRDbackup);
Float_t p4 = track.GetC();
expectedClr = FollowBackProlongation(track);
//track.CookdEdxTimBin(seed->GetID());
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);
+ if ((seed->GetKinkIndex(0) == 0) && (track.Pt() < 1.5)){
+ //UseClusters(&track);
+ }
}
Bool_t isGold = kFALSE;
}
ULong_t status = seed->GetStatus();
+ // reject tracks which failed propagation in the TRD
if((status & AliESDtrack::kTRDout) == 0) continue;
- if((status & AliESDtrack::kTRDin) != 0) continue;
+
+ // reject tracks which are produced by the TRD stand alone track finder.
+ if((status & AliESDtrack::kTRDin) == 0) continue;
nseed++;
track.ResetCovariance(50.0);
AliTRDtrackingChamber *chamber = 0x0;
AliTRDseedV1 tracklet, *ptrTracklet = 0x0;
+ // in case of stand alone tracking we store all the pointers to the tracklets in a temporary array
+ AliTRDseedV1 *tracklets[kNPlanes];
+ memset(tracklets, 0, sizeof(AliTRDseedV1 *) * kNPlanes);
+ for(Int_t ip = 0; ip < kNPlanes; ip++){
+ tracklets[ip] = t.GetTracklet(ip);
+ t.UnsetTracklet(ip);
+ }
// Loop through the TRD layers
for (Int_t ilayer = 0; ilayer < AliTRDgeometry::Nlayer(); ilayer++) {
// BUILD TRACKLET IF NOT ALREADY BUILT
Double_t x = 0., y, z, alpha;
- ptrTracklet = t.GetTracklet(ilayer);
+ ptrTracklet = tracklets[ilayer];
if(!ptrTracklet){
ptrTracklet = new(&tracklet) AliTRDseedV1(ilayer);
ptrTracklet->SetReconstructor(fReconstructor);
x = chamber->GetX();
AliTRDpadPlane *pp = fGeom->GetPadPlane(ilayer, stack);
- tracklet.SetTilt(TMath::Tan(-TMath::DegToRad()*pp->GetTiltingAngle()));
+ tracklet.SetTilt(TMath::Tan(TMath::DegToRad()*pp->GetTiltingAngle()));
tracklet.SetPadLength(pp->GetLengthIPad());
tracklet.SetPlane(ilayer);
tracklet.SetX0(x);
break;
}
+ //ptrTracklet->UseClusters();
}
if(!ptrTracklet->IsOK()){
if(x < 1.) continue; //temporary
nPoints++;
}
}
- fitter->Eval();
+ if(fitter->Eval()) return 1.E10;
+
Double_t z0 = fitter->GetParameter(3);
Double_t dzdx = fitter->GetParameter(4);
}
+//____________________________________________________________________
+Double_t AliTRDtrackerV1::FitKalman(AliTRDtrackV1 *track, AliTRDseedV1 *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"
+//
+// Author : A.Bercuci@gsi.de
+
+ //printf("Start track @ x[%f]\n", track->GetX());
+
+ //prepare marker points along the track
+ Int_t ip = np ? 0 : 1;
+ while(ip<np){
+ if((up?-1:1) * (track->GetX() - points[ip].GetX()) > 0.) break;
+ //printf("AliTRDtrackerV1::FitKalman() : Skip track marker x[%d] = %7.3f. Before track start ( %7.3f ).\n", ip, points[ip].GetX(), track->GetX());
+ ip++;
+ }
+ //if(points) printf("First marker point @ x[%d] = %f\n", ip, points[ip].GetX());
+
+
+ AliTRDseedV1 tracklet, *ptrTracklet = 0x0;
+
+ //Loop through the TRD planes
+ for (Int_t jplane = 0; jplane < kNPlanes; jplane++) {
+ // GET TRACKLET OR BUILT IT
+ Int_t iplane = up ? jplane : kNPlanes - 1 - jplane;
+ if(tracklets){
+ if(!(ptrTracklet = &tracklets[iplane])) continue;
+ }else{
+ if(!(ptrTracklet = track->GetTracklet(iplane))){
+ /*AliTRDtrackerV1 *tracker = 0x0;
+ if(!(tracker = dynamic_cast<AliTRDtrackerV1*>( AliTRDReconstructor::Tracker()))) continue;
+ ptrTracklet = new(&tracklet) AliTRDseedV1(iplane);
+ if(!tracker->MakeTracklet(ptrTracklet, track)) */
+ continue;
+ }
+ }
+ if(!ptrTracklet->IsOK()) continue;
+
+ Double_t x = ptrTracklet->GetX0();
+
+ 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;
+
+ //printf("Propagate to x[%d] = %f\n", ip, points[ip].GetX());
+
+ if(((up?-1:1) * (points[ip].GetX() - track->GetX()) < 0) && !PropagateToX(*track, points[ip].GetX(), fgkMaxStep)) return -1.;
+
+ Double_t xyz[3]; // should also get the covariance
+ track->GetXYZ(xyz); points[ip].SetXYZ(xyz[0], xyz[1], xyz[2]);
+ ip++;
+ }
+ //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(!AdjustSector(track)) return -1;
+ if(TMath::Abs(track->GetSnp()) > fgkMaxSnp) return -1;
+
+ //load tracklet to the tracker and the track
+/* Int_t index;
+ if((index = FindTracklet(ptrTracklet)) < 0){
+ ptrTracklet = SetTracklet(&tracklet);
+ index = fTracklets->GetEntriesFast()-1;
+ }
+ track->SetTracklet(ptrTracklet, index);*/
+
+
+ // register tracklet to track with tracklet creation !!
+ // PropagateBack : loaded tracklet to the tracker and update index
+ // RefitInward : update index
+ // MakeTrack : loaded tracklet to the tracker and update index
+ if(!tracklets) track->SetTracklet(ptrTracklet, -1);
+
+
+ //Calculate the mean material budget along the path inside the chamber
+ Double_t xyz0[3]; track->GetXYZ(xyz0);
+ Double_t alpha = track->GetAlpha();
+ Double_t xyz1[3], y, z;
+ if(!track->GetProlongation(x, y, z)) return -1;
+ xyz1[0] = x * TMath::Cos(alpha) - y * TMath::Sin(alpha);
+ xyz1[1] = +x * TMath::Sin(alpha) + y * TMath::Cos(alpha);
+ xyz1[2] = z;
+ Double_t param[7];
+ AliTracker::MeanMaterialBudget(xyz0, xyz1, param);
+ Double_t xrho = param[0]*param[4]; // density*length
+ Double_t xx0 = param[1]; // radiation length
+
+ //Propagate the track
+ track->PropagateTo(x, xx0, xrho);
+ if (!AdjustSector(track)) break;
+
+ //Update track
+ Double_t chi2 = track->GetPredictedChi2(ptrTracklet);
+ if(chi2<1e+10) track->Update(ptrTracklet, chi2);
+
+ if(!up) continue;
+
+ //Reset material budget if 2 consecutive gold
+ if(iplane>0 && track->GetTracklet(iplane-1) && ptrTracklet->GetN() + track->GetTracklet(iplane-1)->GetN() > 20) track->SetBudget(2, 0.);
+ } // end planes loop
+
+ // extrapolation
+ while(ip < np){
+ if(((up?-1:1) * (points[ip].GetX() - track->GetX()) < 0) && !PropagateToX(*track, points[ip].GetX(), fgkMaxStep)) return -1.;
+
+ Double_t xyz[3]; // should also get the covariance
+ track->GetXYZ(xyz); points[ip].SetXYZ(xyz[0], xyz[1], xyz[2]);
+ ip++;
+ }
+
+ return track->GetChi2();
+}
//_________________________________________________________________________
Float_t AliTRDtrackerV1::CalculateChi2Z(AliTRDseedV1 *tracklets, Double_t offset, Double_t slope, Double_t xref)
Int_t AliTRDtrackerV1::LoadClusters(TTree *cTree)
{
//
- // Fills clusters into TRD tracking_sectors
- // Note that the numbering scheme for the TRD tracking_sectors
- // differs from that of TRD sectors
+ // Fills clusters into TRD tracking sectors
//
-
- if (ReadClusters(fClusters, cTree)) {
- AliError("Problem with reading the clusters !");
+ if(!fReconstructor->IsWritingClusters()){
+ fClusters = AliTRDReconstructor::GetClusters();
+ } else {
+ if (ReadClusters(fClusters, cTree)) {
+ AliError("Problem with reading the clusters !");
+ return 1;
+ }
+ }
+ SetClustersOwner();
+
+ if(!fClusters || !fClusters->GetEntriesFast()){
+ AliInfo("No TRD clusters");
return 1;
}
- Int_t ncl = fClusters->GetEntriesFast(), nin = 0;
- if(!ncl){
- AliInfo("Clusters 0");
+
+ //Int_t nin =
+ BuildTrackingContainers();
+
+ //Int_t ncl = fClusters->GetEntriesFast();
+ //AliInfo(Form("Clusters %d [%6.2f %% in the active volume]", ncl, 100.*float(nin)/ncl));
+
+ return 0;
+}
+
+//_____________________________________________________________________________
+Int_t AliTRDtrackerV1::LoadClusters(TClonesArray *clusters)
+{
+ //
+ // Fills clusters into TRD tracking sectors
+ // Function for use in the HLT
+
+ if(!clusters || !clusters->GetEntriesFast()){
+ AliInfo("No TRD clusters");
return 1;
}
- Int_t icl = ncl;
+ fClusters = clusters;
+ SetClustersOwner();
+
+ //Int_t nin =
+ BuildTrackingContainers();
+
+ //Int_t ncl = fClusters->GetEntriesFast();
+ //AliInfo(Form("Clusters %d [%6.2f %% in the active volume]", ncl, 100.*float(nin)/ncl));
+
+ return 0;
+}
+
+
+//____________________________________________________________________
+Int_t AliTRDtrackerV1::BuildTrackingContainers()
+{
+// Building tracking containers for clusters
+
+ Int_t nin =0, icl = fClusters->GetEntriesFast();
while (icl--) {
AliTRDcluster *c = (AliTRDcluster *) fClusters->UncheckedAt(icl);
if(c->IsInChamber()) nin++;
fTrSec[sector].GetChamber(stack, layer, kTRUE)->InsertCluster(c, icl);
}
- AliInfo(Form("Clusters %d in %6.2f %%", ncl, 100.*float(nin)/ncl));
for(int isector =0; isector<AliTRDgeometry::kNsector; isector++){
if(!fTrSec[isector].GetNChambers()) continue;
fTrSec[isector].Init(fReconstructor);
}
-
- return 0;
+
+ return nin;
}
+
//____________________________________________________________________
void AliTRDtrackerV1::UnloadClusters()
{
if(fTracks) fTracks->Delete();
if(fTracklets) fTracklets->Delete();
- if(fClusters) fClusters->Delete();
+ if(fClusters && IsClustersOwner()) fClusters->Delete();
+ if(fClusters){
+ if(IsClustersOwner()) fClusters->Delete();
+
+ // save clusters array in the reconstructor for further use.
+ if(!fReconstructor->IsWritingClusters()){
+ AliTRDReconstructor::SetClusters(fClusters);
+ SetClustersOwner(kFALSE);
+ } else AliTRDReconstructor::SetClusters(0x0);
+ }
for (int i = 0; i < AliTRDgeometry::kNsector; i++) fTrSec[i].Clear();
// Check track candidates
candidates = 0;
for (Int_t itrack = 0; itrack < ntracks; itrack++) {
- Int_t trackIndex = sort[itrack];
- if (signedTrack[trackIndex] || fakeTrack[trackIndex]) continue;
+ Int_t trackIndex = sort[itrack];
+ if (signedTrack[trackIndex] || fakeTrack[trackIndex]) continue;
- // Calculate track parameters from tracklets seeds
- Int_t labelsall[1000];
- Int_t nlabelsall = 0;
- Int_t naccepted = 0;
- Int_t ncl = 0;
- Int_t nused = 0;
- Int_t nlayers = 0;
- Int_t findable = 0;
- for (Int_t jLayer = 0; jLayer < kNPlanes; jLayer++) {
- Int_t jseed = kNPlanes*trackIndex+jLayer;
- if(!sseed[jseed].IsOK()) continue;
- if (TMath::Abs(sseed[jseed].GetYref(0) / sseed[jseed].GetX0()) < 0.15) findable++;
-
- sseed[jseed].UpdateUsed();
- ncl += sseed[jseed].GetN2();
- nused += sseed[jseed].GetNUsed();
- nlayers++;
-
- // Cooking label
- for (Int_t itime = 0; itime < fgNTimeBins; itime++) {
- if(!sseed[jseed].IsUsable(itime)) continue;
- naccepted++;
- Int_t tindex = 0, ilab = 0;
- while(ilab<3 && (tindex = sseed[jseed].GetClusters(itime)->GetLabel(ilab)) >= 0){
- labelsall[nlabelsall++] = tindex;
- ilab++;
- }
- }
- }
+ // Calculate track parameters from tracklets seeds
+ Int_t labelsall[1000];
+ Int_t nlabelsall = 0;
+ Int_t naccepted = 0;
+ Int_t ncl = 0;
+ Int_t nused = 0;
+ Int_t nlayers = 0;
+ Int_t findable = 0;
+ for (Int_t jLayer = 0; jLayer < kNPlanes; jLayer++) {
+ Int_t jseed = kNPlanes*trackIndex+jLayer;
+ if(!sseed[jseed].IsOK()) continue;
+ if (TMath::Abs(sseed[jseed].GetYref(0) / sseed[jseed].GetX0()) < 0.15) findable++;
+
+ sseed[jseed].UpdateUsed();
+ ncl += sseed[jseed].GetN2();
+ nused += sseed[jseed].GetNUsed();
+ nlayers++;
+
+// // Cooking label
+// for (Int_t itime = 0; itime < fgNTimeBins; itime++) {
+// if(!sseed[jseed].IsUsable(itime)) continue;
+// naccepted++;
+// Int_t tindex = 0, ilab = 0;
+// while(ilab<3 && (tindex = sseed[jseed].GetClusters(itime)->GetLabel(ilab)) >= 0){
+// labelsall[nlabelsall++] = tindex;
+// ilab++;
+// }
+// }
+ }
+
// Filter duplicated tracks
if (nused > 30){
//printf("Skip %d nused %d\n", trackIndex, nused);
}
signedTrack[trackIndex] = kTRUE;
-
- // Build track label - what happens if measured data ???
- Int_t labels[1000];
- Int_t outlab[1000];
- Int_t nlab = 0;
- for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
- Int_t jseed = kNPlanes*trackIndex+iLayer;
- if(!sseed[jseed].IsOK()) continue;
- for(int ilab=0; ilab<2; ilab++){
- if(sseed[jseed].GetLabels(ilab) < 0) continue;
- labels[nlab] = sseed[jseed].GetLabels(ilab);
- nlab++;
- }
- }
- Freq(nlab,labels,outlab,kFALSE);
- Int_t label = outlab[0];
- Int_t frequency = outlab[1];
- Freq(nlabelsall,labelsall,outlab,kFALSE);
- Int_t label1 = outlab[0];
- Int_t label2 = outlab[2];
- Float_t fakeratio = (naccepted - outlab[1]) / Float_t(naccepted);
-
// Sign clusters
AliTRDcluster *cl = 0x0; Int_t clusterIndex = -1;
- for (Int_t jLayer = 0; jLayer < 6; jLayer++) {
+ for (Int_t jLayer = 0; jLayer < kNPlanes; jLayer++) {
Int_t jseed = kNPlanes*trackIndex+jLayer;
if(!sseed[jseed].IsOK()) continue;
if(TMath::Abs(sseed[jseed].GetYfit(1) - sseed[jseed].GetYfit(1)) >= .2) continue; // check this condition with Marian
idx++;
lseed++;
}*/
- Double_t cR = lseed->GetC();
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] = cR;
+ trackParams[5] = lseed->GetC();
Int_t ich = 0; while(!(chamber = stack[ich])) ich++;
trackParams[6] = fGeom->GetSector(chamber->GetDetector());/* *alpha+shift; // Supermodule*/
Int_t nclusters = 0;
AliTRDseedV1 *dseed[6];
- for(int is=0; is<6; is++){
- dseed[is] = new AliTRDseedV1(sseed[trackIndex*6+is]);
- dseed[is]->SetOwner();
- nclusters += sseed[is].GetN2();
+
+ // Build track label - what happens if measured data ???
+ Int_t labels[1000];
+ Int_t outlab[1000];
+ Int_t nlab = 0;
+ for (Int_t iLayer = 0; iLayer < kNPlanes; iLayer++) {
+ Int_t jseed = kNPlanes*trackIndex+iLayer;
+ dseed[iLayer] = new AliTRDseedV1(sseed[jseed]);
+ dseed[iLayer]->SetOwner();
+ nclusters += sseed[jseed].GetN2();
+ if(!sseed[jseed].IsOK()) continue;
+ for(int ilab=0; ilab<2; ilab++){
+ if(sseed[jseed].GetLabels(ilab) < 0) continue;
+ labels[nlab] = sseed[jseed].GetLabels(ilab);
+ nlab++;
+ }
}
+ Freq(nlab,labels,outlab,kFALSE);
+ Int_t label = outlab[0];
+ Int_t frequency = outlab[1];
+ Freq(nlabelsall,labelsall,outlab,kFALSE);
+ Int_t label1 = outlab[0];
+ Int_t label2 = outlab[2];
+ Float_t fakeratio = (naccepted - outlab[1]) / Float_t(naccepted);
+
//Int_t eventNrInFile = esd->GetEventNumberInFile();
//AliInfo(Form("Number of clusters %d.", nclusters));
Int_t eventNumber = AliTRDtrackerDebug::GetEventNumber();
AliWarning("Fail to build a TRD Track.");
continue;
}
+
//AliInfo("End of MakeTrack()");
- AliESDtrack esdTrack;
- esdTrack.UpdateTrackParams(track, AliESDtrack::kTRDout);
- esdTrack.SetLabel(track->GetLabel());
- track->UpdateESDtrack(&esdTrack);
+ AliESDtrack *esdTrack = new ((*esdTrackList)[ntracks0++]) AliESDtrack();
+ esdTrack->UpdateTrackParams(track, AliESDtrack::kTRDout);
+ esdTrack->SetLabel(track->GetLabel());
+ track->UpdateESDtrack(esdTrack);
// write ESD-friends if neccessary
if (fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 0){
AliTRDtrackV1 *calibTrack = new AliTRDtrackV1(*track);
calibTrack->SetOwner();
- esdTrack.AddCalibObject(calibTrack);
+ esdTrack->AddCalibObject(calibTrack);
}
- new ((*esdTrackList)[ntracks0++]) AliESDtrack(esdTrack);
ntracks1++;
AliTRDtrackerDebug::SetTrackNumber(AliTRDtrackerDebug::GetTrackNumber() + 1);
}
// increment counters
ntracks2 += ntracks1;
+
+ if(fReconstructor->IsHLT()) break;
fSieveSeeding++;
// Rebuild plane configurations and indices taking only unused clusters into account
//
AliTRDtrackingChamber *chamber = 0x0;
- AliTRDcluster *c[4] = {0x0, 0x0, 0x0, 0x0}; // initilize seeding clusters
+ AliTRDcluster *c[kNSeedPlanes] = {0x0, 0x0, 0x0, 0x0}; // initilize seeding clusters
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];
Int_t config = ipar[0];
Int_t ntracks = ipar[1];
Int_t planes[kNSeedPlanes]; GetSeedingConfig(config, planes);
-
+ Int_t planesExt[kNPlanes-kNSeedPlanes]; GetExtrapolationConfig(config, planesExt);
+
+
// Init chambers geometry
Int_t ic = 0; while(!(chamber = stack[ic])) ic++;
Int_t istack = fGeom->GetStack(chamber->GetDetector());
AliTRDpadPlane *pp = 0x0;
for(int iplane=0; iplane<kNPlanes; iplane++){
pp = fGeom->GetPadPlane(iplane, istack);
- hL[iplane] = TMath::Tan(-TMath::DegToRad()*pp->GetTiltingAngle());
+ hL[iplane] = TMath::Tan(TMath::DegToRad()*pp->GetTiltingAngle());
padlength[iplane] = pp->GetLengthIPad();
}
// 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());
- for (Int_t il = 0; il < 6; il++) cseed[il].Reset();
+ for (Int_t il = 0; il < kNPlanes; il++) cseed[il].Reset();
FitRieman(c, chi2);
tseed->SetReconstructor(fReconstructor);
Double_t x_anode = stack[iLayer] ? stack[iLayer]->GetX() : x_def[iLayer];
tseed->SetX0(x_anode);
- //if(stack[iLayer]) tseed->SetX0(stack[iLayer]->GetX());
tseed->Init(GetRiemanFitter());
}
if(nUsedCl > 25) break;
mlayers++;
}
+
if(mlayers < kNSeedPlanes){
//AliInfo(Form("Failed updating all seeds %d [%d].", mlayers, kNSeedPlanes));
AliTRDtrackerDebug::SetCandidateNumber(AliTRDtrackerDebug::GetCandidateNumber() + 1);
continue;
}
+
+ // temporary exit door for the HLT
+ if(fReconstructor->IsHLT()){
+ // attach clusters to extrapolation chambers
+ for(int iLayer=0; iLayer<kNPlanes-kNSeedPlanes; iLayer++){
+ Int_t jLayer = planesExt[iLayer];
+ if(!(chamber = stack[jLayer])) continue;
+ cseed[jLayer].AttachClustersIter(chamber, 1000.);
+ }
+ fTrackQuality[ntracks] = 1.; // dummy value
+ ntracks++;
+ if(ntracks == kMaxTracksStack){
+ AliWarning(Form("Number of seeds reached maximum allowed (%d) in stack.", kMaxTracksStack));
+ return ntracks;
+ }
+ cseed += 6;
+ continue;
+ }
+
+
// fit tracklets and cook likelihood
FitTiltedRieman(&cseed[0], kTRUE);// Update Seeds and calculate Likelihood
chi2[0] = GetChi2Y(&cseed[0]);
fSeedLayer[ntracks] = config;/*sLayer;*/
// attach clusters to the extrapolation seeds
- Int_t lextrap[2];
- GetExtrapolationConfig(config, lextrap);
Int_t nusedf = 0; // debug value
- for(int iLayer=0; iLayer<2; iLayer++){
- Int_t jLayer = lextrap[iLayer];
+ for(int iLayer=0; iLayer<kNPlanes-kNSeedPlanes; iLayer++){
+ Int_t jLayer = planesExt[iLayer];
if(!(chamber = stack[jLayer])) continue;
// fit extrapolated seed
// To be discussed with Marian !!
//
- AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
- if (!calibra) AliInfo("Could not get Calibra instance\n");
Double_t alpha = AliTRDgeometry::GetAlpha();
Double_t shift = AliTRDgeometry::GetAlpha()/2.0;
if (nc < 30) return 0x0;
AliTRDtrackV1 *ptrTrack = SetTrack(&track);
+ if(fReconstructor->IsHLT()) return ptrTrack;
+
ptrTrack->CookLabel(.9);
+
// computes PID for track
ptrTrack->CookPID();
// update calibration references using this track
- if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(ptrTrack);
-
+ AliTRDCalibraFillHisto *calibra = AliTRDCalibraFillHisto::Instance();
+ if (!calibra){
+ AliInfo("Could not get Calibra instance\n");
+ if(calibra->GetHisto2d()) calibra->UpdateHistogramsV1(ptrTrack);
+ }
return ptrTrack;
}
}
-void AliTRDtrackerV1::SetReconstructor(const AliTRDReconstructor *rec){
- fReconstructor = rec;
- if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
- if(!fgDebugStreamer)
- fgDebugStreamer = new TTreeSRedirector("TRD.TrackerDebug.root");
- }
+
+//____________________________________________________________________
+void AliTRDtrackerV1::SetReconstructor(const AliTRDReconstructor *rec)
+{
+ fReconstructor = rec;
+ if(fReconstructor->GetStreamLevel(AliTRDReconstructor::kTracker) > 1){
+ if(!fgDebugStreamer){
+ TDirectory *savedir = gDirectory;
+ fgDebugStreamer = new TTreeSRedirector("TRD.TrackerDebug.root");
+ savedir->cd();
+ }
+ }
}
//_____________________________________________________________________________
//
Double_t denominator = fSums[0] * fSums[4] - fSums[1] *fSums[1];
+ if(denominator==0) return;
+
// for(Int_t isum = 0; isum < 5; isum++)
// printf("fSums[%d] = %f\n", isum, fSums[isum]);
// printf("denominator = %f\n", denominator);