// //
///////////////////////////////////////////////////////////////////////////////
+
#include <Riostream.h>
-#include <TFile.h>
#include <TBranch.h>
-#include <TTree.h>
-#include <TObjArray.h>
-#include <TTreeStream.h>
+#include <TFile.h>
#include <TGraph.h>
+#include <TH1D.h>
+#include <TH2D.h>
#include <TLinearFitter.h>
+#include <TObjArray.h>
+#include <TROOT.h>
+#include <TTree.h>
+#include <TTreeStream.h>
#include "AliESD.h"
#include "AliAlignObj.h"
#include "AliTRDtracker.h"
#include "AliTRDReconstructor.h"
#include "AliTRDCalibra.h"
+ClassImp(AliTRDtracker)
-ClassImp(AliTRDtracker)
-
- const Float_t AliTRDtracker::fgkMinClustersInTrack = 0.5;
- const Float_t AliTRDtracker::fgkLabelFraction = 0.8;
- const Double_t AliTRDtracker::fgkMaxChi2 = 12.0;
- const Double_t AliTRDtracker::fgkMaxSnp = 0.95; // Corresponds to tan = 3
- const Double_t AliTRDtracker::fgkMaxStep = 2.0; // Maximal step size in propagation
+const Float_t AliTRDtracker::fgkMinClustersInTrack = 0.5;
+const Float_t AliTRDtracker::fgkLabelFraction = 0.8; // ??
+const Double_t AliTRDtracker::fgkMaxChi2 = 12.0;
+const Double_t AliTRDtracker::fgkMaxSnp = 0.95; // Corresponds to tan = 3
+const Double_t AliTRDtracker::fgkMaxStep = 2.0; // Maximal step size in propagation
//_____________________________________________________________________________
AliTRDtracker::AliTRDtracker()
:AliTracker()
+ ,fHBackfit(0x0)
+ ,fHClSearch(0x0)
+ ,fHRefit(0x0)
+ ,fHX(0x0)
+ ,fHNCl(0x0)
+ ,fHNClTrack(0x0)
+ ,fHMinYPos(0x0)
+ ,fHMinYNeg(0x0)
+ ,fHMinZ(0x0)
+ ,fHMinD(0x0)
+ ,fHDeltaX(0x0)
+ ,fHXCl(0x0)
,fGeom(0)
,fNclusters(0)
,fClusters(0)
}
}
+ InitLogHists();
+
}
//_____________________________________________________________________________
AliTRDtracker::AliTRDtracker(const AliTRDtracker &t)
:AliTracker(t)
+ ,fHBackfit(0x0)
+ ,fHClSearch(0x0)
+ ,fHRefit(0x0)
+ ,fHX(0x0)
+ ,fHNCl(0x0)
+ ,fHNClTrack(0x0)
+ ,fHMinYPos(0x0)
+ ,fHMinYNeg(0x0)
+ ,fHMinZ(0x0)
+ ,fHMinD(0x0)
+ ,fHDeltaX(0x0)
+ ,fHXCl(0x0)
,fGeom(0)
,fNclusters(0)
,fClusters(0)
//
// Copy constructor
//
+
}
//_____________________________________________________________________________
AliTRDtracker::AliTRDtracker(const TFile *geomfile)
:AliTracker()
+ ,fHBackfit(0x0)
+ ,fHClSearch(0x0)
+ ,fHRefit(0x0)
+ ,fHX(0x0)
+ ,fHNCl(0x0)
+ ,fHNClTrack(0x0)
+ ,fHMinYPos(0x0)
+ ,fHMinYNeg(0x0)
+ ,fHMinZ(0x0)
+ ,fHMinD(0x0)
+ ,fHDeltaX(0x0)
+ ,fHXCl(0x0)
,fGeom(0)
,fNclusters(0)
,fClusters(new TObjArray(2000))
fDebugStreamer = new TTreeSRedirector("TRDdebug.root");
savedir->cd();
+
+ InitLogHists();
}
// ExB correction
//
Double_t vdrift = AliTRDcalibDB::Instance()->GetVdrift(cluster->GetDetector(),0,0);
- Double_t exB = AliTRDcalibDB::Instance()->GetOmegaTau(vdrift);
+ Double_t exB = AliTRDcalibDB::Instance()->GetOmegaTau(vdrift,-AliTracker::GetBz()*0.1);
AliTRDCommonParam *commonParam = AliTRDCommonParam::Instance();
AliTRDpadPlane *padPlane = commonParam->GetPadPlane(plane,chamber);
// // ExB correction
// //
// Double_t vdrift = AliTRDcalibDB::Instance()->GetVdrift(cluster->GetDetector(),0,0);
-// Double_t exB = AliTRDcalibDB::Instance()->GetOmegaTau(vdrift);
+// Double_t exB = AliTRDcalibDB::Instance()->GetOmegaTau(vdrift,-AliTracker::GetBz()*0.1);
// //
// AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance();
// by the TPC tracker.
//
- Int_t found = 0;
+ Int_t found = 0; // number of tracks found
Float_t foundMin = 20.0;
Int_t n = event->GetNumberOfTracks();
Double_t covariance[15];
seed->GetExternalCovariance(covariance);
quality[i] = covariance[0]+covariance[2];
+ //quality[i] = covariance[0];
}
TMath::Sort(n,quality,index,kFALSE);
//AliESDtrack *seed = event->GetTrack(i);
AliESDtrack *seed = event->GetTrack(index[i]);
+ fHBackfit->Fill(0);
ULong_t status = seed->GetStatus();
if ((status & AliESDtrack::kTPCout) == 0) {
+ fHBackfit->Fill(1);
continue;
}
+
if ((status & AliESDtrack::kTRDout) != 0) {
+ fHBackfit->Fill(2);
continue;
}
seed->UpdateTrackParams(track,AliESDtrack::kTRDbackup); // Make backup
fNseeds++;
Float_t p4 = track->GetC();
-
Int_t expectedClr = FollowBackProlongation(*track);
+
+ fHBackfit->Fill(3);
+ fHX->Fill(track->GetX());
+
+
+ // store the last measurement
+ /*
+ fHNClTrack->Fill(track->GetNumberOfClusters());
+ if (track->GetNumberOfClusters() >= foundMin) {
+
+ fHBackfit->Fill(4);
+ track->CookdEdx();
+ CookdEdxTimBin(*track);
+ CookLabel(track,1 - fgkLabelFraction);
+ if (track->GetBackupTrack()) {
+ //fHBackfit->Fill(5);
+ UseClusters(track->GetBackupTrack());
+ seed->UpdateTrackParams(track->GetBackupTrack(),AliESDtrack::kTRDbackup);
+ }
+ }
+ */
+
+ /**/
+ // inter-tracks competition ???
if ((TMath::Abs(track->GetC() - p4) / TMath::Abs(p4) < 0.2) ||
(TMath::Abs(track->GetPt()) > 0.8)) {
-
+
+ fHBackfit->Fill(4);
+
//
// Make backup for back propagation
//
-
+
Int_t foundClr = track->GetNumberOfClusters();
if (foundClr >= foundMin) {
track->CookdEdx();
// Sign only gold tracks
if (track->GetChi2() / track->GetNumberOfClusters() < 4) {
- if ((seed->GetKinkIndex(0) == 0) &&
+ if ((seed->GetKinkIndex(0) == 0) &&
(TMath::Abs(track->GetPt()) < 1.5)) {
UseClusters(track);
}
//seed->UpdateTrackParams(track, AliESDtrack::kTRDbackup);
if (track->GetBackupTrack()) {
seed->UpdateTrackParams(track->GetBackupTrack(),AliESDtrack::kTRDbackup);
+
}
isGold = kTRUE;
+ //fHBackfit->Fill()
}
// Almost gold track
if ((!isGold) &&
(track->GetBackupTrack())) {
- if ((track->GetBackupTrack()->GetNumberOfClusters() > foundMin) &&
- ((track->GetBackupTrack()->GetChi2()/(track->GetBackupTrack()->GetNumberOfClusters()+1)) < 7)) {
+ if ((track->GetBackupTrack()->GetNumberOfClusters() > foundMin) &&
+ ((track->GetBackupTrack()->GetChi2()/(track->GetBackupTrack()->GetNumberOfClusters()+1)) < 7)) {
seed->UpdateTrackParams(track->GetBackupTrack(),AliESDtrack::kTRDbackup);
isGold = kTRUE;
}
}
- if ((track->StatusForTOF() > 0) &&
- (track->fNCross == 0) &&
- (Float_t(track->fN)/Float_t(track->fNExpected) > 0.4)) {
+ if ((track->StatusForTOF() > 0) &&
+ (track->GetNCross() == 0) &&
+ (Float_t(track->GetNumberOfClusters()) / Float_t(track->GetNExpected()) > 0.4)) {
//seed->UpdateTrackParams(track->GetBackupTrack(), AliESDtrack::kTRDbackup);
}
}
-
}
+ /**/
+ /**/
// Debug part of tracking
TTreeSRedirector &cstream = *fDebugStreamer;
Int_t eventNr = event->GetEventNumber();
<< "\n";
}
}
+ /**/
// Propagation to the TOF (I.Belikov)
if (track->GetStop() == kFALSE) {
-
+ fHBackfit->Fill(5);
+
Double_t xtof = 371.0;
+ Double_t xTOF0 = 370.0;
+
Double_t c2 = track->GetSnp() + track->GetC() * (xtof - track->GetX());
if (TMath::Abs(c2) >= 0.99) {
+
+ fHBackfit->Fill(6);
delete track;
continue;
}
- Double_t xTOF0 = 370.0;
+
PropagateToX(*track,xTOF0,fgkMaxStep);
// Energy losses taken to the account - check one more time
c2 = track->GetSnp() + track->GetC() * (xtof - track->GetX());
if (TMath::Abs(c2) >= 0.99) {
+
+ fHBackfit->Fill(7);
delete track;
continue;
}
+
+ //if (!PropagateToX(*track,xTOF0,fgkMaxStep)) {
+ // fHBackfit->Fill(7);
+ //delete track;
+ // continue;
+ //}
Double_t ymax = xtof * TMath::Tan(0.5 * AliTRDgeometry::GetAlpha());
Double_t y;
track->GetYAt(xtof,GetBz(),y);
- if (y > ymax) {
+ if (y > ymax) {
if (!track->Rotate( AliTRDgeometry::GetAlpha())) {
+ fHBackfit->Fill(8);
delete track;
continue;
}
}
else if (y < -ymax) {
if (!track->Rotate(-AliTRDgeometry::GetAlpha())) {
+ fHBackfit->Fill(9);
delete track;
continue;
}
}
-
+
if (track->PropagateTo(xtof)) {
seed->UpdateTrackParams(track,AliESDtrack::kTRDout);
+ fHBackfit->Fill(10);
+
for (Int_t i = 0; i < AliESDtrack::kNPlane; i++) {
for (Int_t j = 0; j < AliESDtrack::kNSlice; j++) {
seed->SetTRDsignals(track->GetPIDsignals(i,j),i,j);
}
//seed->SetTRDtrack(new AliTRDtrack(*track));
if (track->GetNumberOfClusters() > foundMin) {
+ fHBackfit->Fill(11);
found++;
}
}
}
else {
-
+
+ fHBackfit->Fill(12);
+
if ((track->GetNumberOfClusters() > 15) &&
(track->GetNumberOfClusters() > 0.5*expectedClr)) {
+
seed->UpdateTrackParams(track,AliESDtrack::kTRDout);
+ fHBackfit->Fill(13);
+
//seed->SetStatus(AliESDtrack::kTRDStop);
for (Int_t i = 0; i < AliESDtrack::kNPlane; i++) {
for (Int_t j = 0; j <AliESDtrack::kNSlice; j++) {
}
seed->SetTRDQuality(track->StatusForTOF());
- seed->SetTRDBudget(track->fBudget[0]);
+ seed->SetTRDBudget(track->GetBudget(0));
+ fHBackfit->Fill(14);
delete track;
-
}
AliInfo(Form("Number of seeds: %d",fNseeds));
delete [] index;
delete [] quality;
+ SaveLogHists();
+
return 0;
-
}
//_____________________________________________________________________________
AliESDtrack *seed = event->GetTrack(i);
new (&seed2) AliTRDtrack(*seed);
+ fHRefit->Fill(0);
+
if (seed2.GetX() < 270.0) {
seed->UpdateTrackParams(&seed2,AliESDtrack::kTRDbackup); // Backup TPC track - only update
+ fHRefit->Fill(1);
continue;
}
ULong_t status = seed->GetStatus();
if ((status & AliESDtrack::kTRDout) == 0) {
+ fHRefit->Fill(2);
continue;
}
if ((status & AliESDtrack::kTRDin) != 0) {
+ fHRefit->Fill(3);
continue;
}
+
nseed++;
+ fHRefit->Fill(4);
seed2.ResetCovariance(50.0);
Double_t xTPC = 250.0;
if (PropagateToX(t,xTPC,fgkMaxStep)) {
+
seed->UpdateTrackParams(pt,AliESDtrack::kTRDrefit);
+ fHRefit->Fill(5);
+
for (Int_t i = 0; i < AliESDtrack::kNPlane; i++) {
for (Int_t j = 0; j < AliESDtrack::kNSlice; j++) {
seed->SetTRDsignals(pt->GetPIDsignals(i,j),i,j);
}
else {
// If not prolongation to TPC - propagate without update
+ fHRefit->Fill(5);
AliTRDtrack *seed2 = new AliTRDtrack(*seed);
seed2->ResetCovariance(5.0);
AliTRDtrack *pt2 = new AliTRDtrack(*seed2,seed2->GetAlpha());
pt2->CookdEdx( );
CookdEdxTimBin(*pt2);
seed->UpdateTrackParams(pt2,AliESDtrack::kTRDrefit);
+ fHRefit->Fill(6);
+
for (Int_t i = 0; i < AliESDtrack::kNPlane; i++) {
for (Int_t j = 0; j < AliESDtrack::kNSlice; j++) {
seed->SetTRDsignals(pt2->GetPIDsignals(i,j),i,j);
AliInfo(Form("Number of loaded seeds: %d",nseed));
AliInfo(Form("Number of found tracks from loaded seeds: %d",found));
+ SaveLogHists();
return 0;
-
}
//_____________________________________________________________________________
Int_t ilayer = GetGlobalTimeBin(0,iplane,itime);
expectedNumberOfClusters++;
- t.fNExpected++;
+ t.SetNExpected(t.GetNExpected() + 1);
if (t.GetX() > 345.0) {
- t.fNExpectedLast++;
+ t.SetNExpectedLast(t.GetNExpectedLast() + 1);
}
AliTRDpropagationLayer &timeBin = *(fTrSec[sector]->GetLayer(ilayer));
- AliTRDcluster *cl = 0;
+ AliTRDcluster *cl = 0;
UInt_t index = 0;
Double_t maxChi2 = fgkMaxChi2;
x = timeBin.GetX();
Int_t det = cl->GetDetector();
Int_t plane = fGeom->GetPlane(det);
if (t.GetX() > 345.0) {
- t.fNLast++;
- t.fChi2Last += maxChi2;
+ t.SetNLast(t.GetNLast() + 1);
+ t.SetChi2Last(t.GetChi2Last() + maxChi2);
}
Double_t xcluster = cl->GetX();
}
maxChi2 = t.GetPredictedChi2(cl,h01);
- if (!t.UpdateMI(cl,maxChi2,index,h01,plane)) {
- // ????
- }
+ if (maxChi2<1e+10)
+ if (!t.UpdateMI(cl,maxChi2,index,h01,plane)) {
+ // ????
+ }
}
// Returns the number of clusters expected to be found in sensitive layers
// Use GEO manager for material Description
//
+ // return number of assigned clusters ?
+ //
+
Int_t sector;
Int_t clusters[1000];
if (!calibra) {
AliInfo("Could not get Calibra instance\n");
}
- if (calibra->GetMItracking()) {
- calibra->Resettrack();
+ if (calibra->GetMITracking()) {
+ calibra->ResetTrack();
}
for (Int_t i = 0; i < 1000; i++) {
for (Int_t iplane = 0; iplane < AliESDtrack::kNPlane; iplane++) {
+ int hb = iplane * 10;
+ fHClSearch->Fill(hb);
+
Int_t row0 = GetGlobalTimeBin(0,iplane,GetTimeBinsPerPlane()-1);
Int_t rowlast = GetGlobalTimeBin(0,iplane,0);
Double_t currentx = fTrSec[0]->GetLayer(row0)->GetX();
if (currentx < t.GetX()) {
+ fHClSearch->Fill(hb+1);
continue;
}
//
if (currentx > (fgkMaxStep + t.GetX())) {
if (!PropagateToX(t,currentx-fgkMaxStep,fgkMaxStep)) {
+ fHClSearch->Fill(hb+2);
break;
}
}
if (!AdjustSector(&t)) {
+ fHClSearch->Fill(hb+3);
break;
}
if (TMath::Abs(t.GetSnp()) > fgkMaxSnp) {
+ fHClSearch->Fill(hb+4);
break;
}
// End global position
x = fTrSec[0]->GetLayer(rowlast)->GetX();
if (!t.GetProlongation(x,y,z)) {
+ fHClSearch->Fill(hb+5);
break;
}
xyz1[0] = x * TMath::Cos(t.GetAlpha()) - y * TMath::Sin(t.GetAlpha());
//
sector = t.GetSector();
Float_t ncl = FindClusters(sector,row0,rowlast,&t,clusters,tracklet);
+ fHNCl->Fill(tracklet.GetN());
+
if (tracklet.GetN() < GetTimeBinsPerPlane()/3) {
+ fHClSearch->Fill(hb+6);
continue;
}
Int_t ilayer = GetGlobalTimeBin(0, iplane,itime);
expectedNumberOfClusters++;
- t.fNExpected++;
+ t.SetNExpected(t.GetNExpected() + 1);
if (t.GetX() > 345.0) {
- t.fNExpectedLast++;
+ t.SetNExpectedLast(t.GetNExpectedLast() + 1);
}
AliTRDpropagationLayer &timeBin = *(fTrSec[sector]->GetLayer(ilayer));
- AliTRDcluster *cl = 0;
+ AliTRDcluster *cl = 0;
UInt_t index = 0;
Double_t maxChi2 = fgkMaxChi2;
x = timeBin.GetX();
Int_t det = cl->GetDetector();
Int_t plane = fGeom->GetPlane(det);
if (t.GetX() > 345.0) {
- t.fNLast++;
- t.fChi2Last += maxChi2;
+ t.SetNLast(t.GetNLast() + 1);
+ t.SetChi2Last(t.GetChi2Last() + maxChi2);
}
Double_t xcluster = cl->GetX();
t.PropagateTo(xcluster,radLength,rho);
maxChi2 = t.GetPredictedChi2(cl,h01);
- if (!t.UpdateMI(cl,maxChi2,index,h01,plane)) {
- if (!t.Update(cl,maxChi2,index,h01)) {
- // ????
- }
- }
+ if (maxChi2<1e+10)
+ if (!t.UpdateMI(cl,maxChi2,index,h01,plane)) {
+ if (!t.Update(cl,maxChi2,index,h01)) {
+ // ????
+ }
+ }
- if (calibra->GetMItracking()) {
+ if (calibra->GetMITracking()) {
calibra->UpdateHistograms(cl,&t);
}
// Reset material budget if 2 consecutive gold
if (plane > 0) {
- if (t.fTracklets[plane].GetN() + t.fTracklets[plane-1].GetN() > 20) {
- t.fBudget[2] = 0;
+ if ((t.GetTracklets(plane).GetN() + t.GetTracklets(plane-1).GetN()) > 20) {
+ t.SetBudget(2,0.0);
}
}
}
ratio0 = ncl / Float_t(fTimeBinsPerPlane);
- Float_t ratio1 = Float_t(t.fN+1) / Float_t(t.fNExpected+1.0);
- if ((tracklet.GetChi2() < 18.0) &&
- (ratio0 > 0.8) &&
- (ratio1 > 0.6) &&
- (ratio0+ratio1 > 1.5) &&
- (t.GetNCross() == 0) &&
- (TMath::Abs(t.GetSnp()) < 0.85) &&
- (t.fN > 20)){
+ Float_t ratio1 = Float_t(t.GetNumberOfClusters()+1) / Float_t(t.GetNExpected()+1);
+ if ((tracklet.GetChi2() < 18.0) &&
+ (ratio0 > 0.8) &&
+ (ratio1 > 0.6) &&
+ (ratio0+ratio1 > 1.5) &&
+ (t.GetNCross() == 0) &&
+ (TMath::Abs(t.GetSnp()) < 0.85) &&
+ (t.GetNumberOfClusters() > 20)){
+ //if (ratio0 > 0.8) {
t.MakeBackupTrack(); // Make backup of the track until is gold
}
}
return expectedNumberOfClusters;
-
}
//_____________________________________________________________________________
Int_t plane = fGeom->GetPlane(detector);
Int_t trackingSector = CookSectorIndex(sector);
- if (c->GetLabel(0) > 0) {
+ //if (c->GetLabel(0) > 0) {
+ if (c->GetQ() > 10) {
Int_t chamber = fGeom->GetChamber(detector);
fHoles[chamber][trackingSector] = kFALSE;
}
index = ncl;
// Apply pos correction
- Transform(c);
- fTrSec[trackingSector]->GetLayer(layer)->InsertCluster(c,index);
+ Transform(c);
+ fHXCl->Fill(c->GetX());
+ fTrSec[trackingSector]->GetLayer(layer)->SetX(c->GetX());
+ fTrSec[trackingSector]->GetLayer(layer)->InsertCluster(c,index);
}
return 0;
chi2R = 0.0;
for (Int_t iLayer = 0; iLayer < 4; iLayer++) {
- cseed[sLayer+iLayer].fZref[0] = rieman.GetZat(xcl[sLayer+iLayer]);
- chi2Z += (cseed[sLayer+iLayer].fZref[0]- zcl[sLayer+iLayer])
- * (cseed[sLayer+iLayer].fZref[0]- zcl[sLayer+iLayer]);
- cseed[sLayer+iLayer].fZref[1] = rieman.GetDZat(xcl[sLayer+iLayer]);
- cseed[sLayer+iLayer].fYref[0] = rieman.GetYat(xcl[sLayer+iLayer]);
- chi2R += (cseed[sLayer+iLayer].fYref[0]- ycl[sLayer+iLayer])
- * (cseed[sLayer+iLayer].fYref[0]- ycl[sLayer+iLayer]);
- cseed[sLayer+iLayer].fYref[1] = rieman.GetDYat(xcl[sLayer+iLayer]);
+ cseed[sLayer+iLayer].SetZref(0,rieman.GetZat(xcl[sLayer+iLayer]));
+ chi2Z += (cseed[sLayer+iLayer].GetZref(0)- zcl[sLayer+iLayer])
+ * (cseed[sLayer+iLayer].GetZref(0)- zcl[sLayer+iLayer]);
+ cseed[sLayer+iLayer].SetZref(1,rieman.GetDZat(xcl[sLayer+iLayer]));
+ cseed[sLayer+iLayer].SetYref(0,rieman.GetYat(xcl[sLayer+iLayer]));
+ chi2R += (cseed[sLayer+iLayer].GetYref(0)- ycl[sLayer+iLayer])
+ * (cseed[sLayer+iLayer].GetYref(0)- ycl[sLayer+iLayer]);
+ cseed[sLayer+iLayer].SetYref(1,rieman.GetDYat(xcl[sLayer+iLayer]));
}
if (TMath::Sqrt(chi2R) > 1.0/iter) {
continue;
Float_t minmax[2] = { -100.0, 100.0 };
for (Int_t iLayer = 0; iLayer < 4; iLayer++) {
Float_t max = zcl[sLayer+iLayer]+padlength[sLayer+iLayer] * 0.5
- + 1.0 - cseed[sLayer+iLayer].fZref[0];
+ + 1.0 - cseed[sLayer+iLayer].GetZref(0);
if (max < minmax[1]) {
minmax[1] = max;
}
Float_t min = zcl[sLayer+iLayer]-padlength[sLayer+iLayer] * 0.5
- - 1.0 - cseed[sLayer+iLayer].fZref[0];
+ - 1.0 - cseed[sLayer+iLayer].GetZref(0);
if (min > minmax[0]) {
minmax[0] = min;
}
for (Int_t jLayer = 0; jLayer < 4; jLayer++) {
- cseed[sLayer+jLayer].fTilt = hL[sLayer+jLayer];
- cseed[sLayer+jLayer].fPadLength = padlength[sLayer+jLayer];
- cseed[sLayer+jLayer].fX0 = xcl[sLayer+jLayer];
+ cseed[sLayer+jLayer].SetTilt(hL[sLayer+jLayer]);
+ cseed[sLayer+jLayer].SetPadLength(padlength[sLayer+jLayer]);
+ cseed[sLayer+jLayer].SetX0(xcl[sLayer+jLayer]);
for (Int_t iter = 0; iter < 2; iter++) {
if (iter > 0) {
// Try 2 pad-rows in second iteration
- zexp = tseed.fZref[0] + tseed.fZref[1]*dxlayer;
+ zexp = tseed.GetZref(0) + tseed.GetZref(1) * dxlayer;
if (zexp > cl[sLayer+jLayer]->GetZ()) {
zexp = cl[sLayer+jLayer]->GetZ() + padlength[sLayer+jLayer]*0.5;
}
}
}
- Double_t yexp = tseed.fYref[0] + tseed.fYref[1]*dxlayer;
+ Double_t yexp = tseed.GetYref(0) + tseed.GetYref(1) * dxlayer;
Int_t index = layer.FindNearestCluster(yexp,zexp,kRoad1y,roadz);
if (index <= 0) {
continue;
}
AliTRDcluster *cl = (AliTRDcluster *) GetCluster(index);
- tseed.fIndexes[iTime] = index;
- tseed.fClusters[iTime] = cl; // Register cluster
- tseed.fX[iTime] = dxlayer; // Register cluster
- tseed.fY[iTime] = cl->GetY(); // Register cluster
- tseed.fZ[iTime] = cl->GetZ(); // Register cluster
+ tseed.SetIndexes(iTime,index);
+ tseed.SetClusters(iTime,cl); // Register cluster
+ tseed.SetX(iTime,dxlayer); // Register cluster
+ tseed.SetY(iTime,cl->GetY()); // Register cluster
+ tseed.SetZ(iTime,cl->GetZ()); // Register cluster
}
tseed.Update();
// Count the number of clusters and distortions into quality
- Float_t dangle = tseed.fYfit[1] - tseed.fYref[1];
- Float_t tquality = (18.0 - tseed.fN2) / 2.0 + TMath::Abs(dangle) / 0.1
- + TMath::Abs(tseed.fYfit[0] - tseed.fYref[0]) / 0.2
- + 2.0 * TMath::Abs(tseed.fMeanz-tseed.fZref[0]) / padlength[jLayer];
+ Float_t dangle = tseed.GetYfit(1) - tseed.GetYref(1);
+ Float_t tquality = (18.0 - tseed.GetN2()) / 2.0 + TMath::Abs(dangle) / 0.1
+ + TMath::Abs(tseed.GetYfit(0) - tseed.GetYref(0)) / 0.2
+ + 2.0 * TMath::Abs(tseed.GetMeanz() - tseed.GetZref(0)) / padlength[jLayer];
if ((iter == 0) && tseed.IsOK()) {
cseed[sLayer+jLayer] = tseed;
quality = tquality;
cseed[sLayer+jLayer].CookLabels();
cseed[sLayer+jLayer].UpdateUsed();
- nusedCl += cseed[sLayer+jLayer].fNUsed;
+ nusedCl += cseed[sLayer+jLayer].GetNUsed();
if (nusedCl > 25) {
isOK = kFALSE;
break;
nclusters = 0;
for (Int_t iLayer = 0; iLayer < 4; iLayer++) {
if (cseed[sLayer+iLayer].IsOK()) {
- nclusters += cseed[sLayer+iLayer].fN2;
+ nclusters += cseed[sLayer+iLayer].GetN2();
}
}
rieman.Reset();
for (Int_t iLayer = 0; iLayer < 4; iLayer++) {
rieman.AddPoint(xcl[sLayer+iLayer]
- ,cseed[sLayer+iLayer].fYfitR[0]
- ,cseed[sLayer+iLayer].fZProb
+ ,cseed[sLayer+iLayer].GetYfitR(0)
+ ,cseed[sLayer+iLayer].GetZProb()
,1
,10);
}
chi2Z = 0.0;
for (Int_t iLayer = 0; iLayer < 4; iLayer++) {
- cseed[sLayer+iLayer].fYref[0] = rieman.GetYat(xcl[sLayer+iLayer]);
- chi2R += (cseed[sLayer+iLayer].fYref[0] - cseed[sLayer+iLayer].fYfitR[0])
- * (cseed[sLayer+iLayer].fYref[0] - cseed[sLayer+iLayer].fYfitR[0]);
- cseed[sLayer+iLayer].fYref[1] = rieman.GetDYat(xcl[sLayer+iLayer]);
- cseed[sLayer+iLayer].fZref[0] = rieman.GetZat(xcl[sLayer+iLayer]);
- chi2Z += (cseed[sLayer+iLayer].fZref[0] - cseed[sLayer+iLayer].fMeanz)
- * (cseed[sLayer+iLayer].fZref[0]- cseed[sLayer+iLayer].fMeanz);
- cseed[sLayer+iLayer].fZref[1] = rieman.GetDZat(xcl[sLayer+iLayer]);
+ cseed[sLayer+iLayer].SetYref(0,rieman.GetYat(xcl[sLayer+iLayer]));
+ chi2R += (cseed[sLayer+iLayer].GetYref(0) - cseed[sLayer+iLayer].GetYfitR(0))
+ * (cseed[sLayer+iLayer].GetYref(0) - cseed[sLayer+iLayer].GetYfitR(0));
+ cseed[sLayer+iLayer].SetYref(1,rieman.GetDYat(xcl[sLayer+iLayer]));
+ cseed[sLayer+iLayer].SetZref(0,rieman.GetZat(xcl[sLayer+iLayer]));
+ chi2Z += (cseed[sLayer+iLayer].GetZref(0) - cseed[sLayer+iLayer].GetMeanz())
+ * (cseed[sLayer+iLayer].GetZref(0) - cseed[sLayer+iLayer].GetMeanz());
+ cseed[sLayer+iLayer].SetZref(1,rieman.GetDZat(xcl[sLayer+iLayer]));
}
Double_t curv = rieman.GetC();
//
// Likelihoods
//
- Double_t sumda = TMath::Abs(cseed[sLayer+0].fYfitR[1] - cseed[sLayer+0].fYref[1])
- + TMath::Abs(cseed[sLayer+1].fYfitR[1] - cseed[sLayer+1].fYref[1])
- + TMath::Abs(cseed[sLayer+2].fYfitR[1] - cseed[sLayer+2].fYref[1])
- + TMath::Abs(cseed[sLayer+3].fYfitR[1]- cseed[sLayer+3].fYref[1]);
+ Double_t sumda = TMath::Abs(cseed[sLayer+0].GetYfitR(1) - cseed[sLayer+0].GetYref(1))
+ + TMath::Abs(cseed[sLayer+1].GetYfitR(1) - cseed[sLayer+1].GetYref(1))
+ + TMath::Abs(cseed[sLayer+2].GetYfitR(1) - cseed[sLayer+2].GetYref(1))
+ + TMath::Abs(cseed[sLayer+3].GetYfitR(1) - cseed[sLayer+3].GetYref(1));
Double_t likea = TMath::Exp(-sumda*10.6);
Double_t likechi2 = 0.0000000001;
if (chi2R < 0.5) {
Double_t likechi2z = TMath::Exp(-chi2Z * 0.088) / TMath::Exp(-chi2Z * 0.019);
Double_t likeN = TMath::Exp(-(72 - nclusters) * 0.19);
Double_t like = likea * likechi2 * likechi2z * likeN;
- Double_t likePrimY = TMath::Exp(-TMath::Abs(cseed[sLayer+0].fYref[1] - 130.0*curv) * 1.9);
- Double_t likePrimZ = TMath::Exp(-TMath::Abs(cseed[sLayer+0].fZref[1]
- - cseed[sLayer+0].fZref[0] / xcl[sLayer+0]) * 5.9);
+ Double_t likePrimY = TMath::Exp(-TMath::Abs(cseed[sLayer+0].GetYref(1) - 130.0*curv) * 1.9);
+ Double_t likePrimZ = TMath::Exp(-TMath::Abs(cseed[sLayer+0].GetZref(1)
+ - cseed[sLayer+0].GetZref(0) / xcl[sLayer+0]) * 5.9);
Double_t likePrim = TMath::Max(likePrimY*likePrimZ,0.0005);
seedquality[registered] = like;
for (Int_t iLayer = 0; iLayer < 2; iLayer++) {
Int_t jLayer = tLayer[iLayer]; // Set tracking layer
cseed[jLayer].Reset();
- cseed[jLayer].fTilt = hL[jLayer];
- cseed[jLayer].fPadLength = padlength[jLayer];
- cseed[jLayer].fX0 = xcl[jLayer];
+ cseed[jLayer].SetTilt(hL[jLayer]);
+ cseed[jLayer].SetPadLength(padlength[jLayer]);
+ cseed[jLayer].SetX0(xcl[jLayer]);
// Get pad length and rough cluster
- Int_t indexdummy = reflayers[jLayer]->FindNearestCluster(cseed[jLayer].fYref[0]
- ,cseed[jLayer].fZref[0]
+ Int_t indexdummy = reflayers[jLayer]->FindNearestCluster(cseed[jLayer].GetYref(0)
+ ,cseed[jLayer].GetZref(0)
,kRoad2y
,kRoad2z);
if (indexdummy <= 0) {
if ((jLayer == 5) && !(cseed[4].IsOK())) {
continue; // break not allowed
}
- Float_t zexp = cseed[jLayer].fZref[0];
+ Float_t zexp = cseed[jLayer].GetZref(0);
Double_t zroad = padlength[jLayer] * 0.5 + 1.0;
for (Int_t iter = 0; iter < 2; iter++) {
for (Int_t iTime = 2; iTime < 20; iTime++) {
AliTRDpropagationLayer &layer = *(fTrSec[ns]->GetLayer(layers[jLayer][1]-iTime));
Double_t dxlayer = layer.GetX()-xcl[jLayer];
- Double_t yexp = tseed.fYref[0] + tseed.fYref[1]*dxlayer;
+ Double_t yexp = tseed.GetYref(0) + tseed.GetYref(1) * dxlayer;
Float_t yroad = kRoad1y;
Int_t index = layer.FindNearestCluster(yexp,zexp,yroad,zroad);
if (index <= 0) {
continue;
}
AliTRDcluster *cl = (AliTRDcluster *) GetCluster(index);
- tseed.fIndexes[iTime] = index;
- tseed.fClusters[iTime] = cl; // Register cluster
- tseed.fX[iTime] = dxlayer; // Register cluster
- tseed.fY[iTime] = cl->GetY(); // Register cluster
- tseed.fZ[iTime] = cl->GetZ(); // Register cluster
+ tseed.SetIndexes(iTime,index);
+ tseed.SetClusters(iTime,cl); // Register cluster
+ tseed.SetX(iTime,dxlayer); // Register cluster
+ tseed.SetY(iTime,cl->GetY()); // Register cluster
+ tseed.SetZ(iTime,cl->GetZ()); // Register cluster
}
tseed.Update();
if (tseed.IsOK()) {
- Float_t dangle = tseed.fYfit[1] - tseed.fYref[1];
- Float_t tquality = (18.0 - tseed.fN2)/2.0 + TMath::Abs(dangle) / 0.1
- + TMath::Abs(tseed.fYfit[0] - tseed.fYref[0]) / 0.2
- + 2.0 * TMath::Abs(tseed.fMeanz-tseed.fZref[0]) / padlength[jLayer];
+ Float_t dangle = tseed.GetYfit(1) - tseed.GetYref(1);
+ Float_t tquality = (18.0 - tseed.GetN2())/2.0 + TMath::Abs(dangle) / 0.1
+ + TMath::Abs(tseed.GetYfit(0) - tseed.GetYref(0)) / 0.2
+ + 2.0 * TMath::Abs(tseed.GetMeanz() - tseed.GetZref(0)) / padlength[jLayer];
if (tquality < quality) {
cseed[jLayer] = tseed;
quality = tquality;
if ( cseed[jLayer].IsOK()) {
cseed[jLayer].CookLabels();
cseed[jLayer].UpdateUsed();
- nusedf += cseed[jLayer].fNUsed;
+ nusedf += cseed[jLayer].GetNUsed();
AliTRDseed::FitRiemanTilt(cseed,kTRUE);
}
for (Int_t jLayer = 0; jLayer < 6; jLayer++) {
if (bseed[jLayer].IsOK()) {
AliTRDseed &tseed = bseed[jLayer];
- Double_t zcor = tseed.fTilt * (tseed.fZProb - tseed.fZref[0]);
- Float_t dangle = tseed.fYfit[1] - tseed.fYref[1];
- Float_t tquality = (18.0 - tseed.fN2) / 2.0 + TMath::Abs(dangle) / 0.1
- + TMath::Abs(tseed.fYfit[0] - (tseed.fYref[0] - zcor)) / 0.2
- + 2.0 * TMath::Abs(tseed.fMeanz - tseed.fZref[0]) / padlength[jLayer];
+ Double_t zcor = tseed.GetTilt() * (tseed.GetZProb() - tseed.GetZref(0));
+ Float_t dangle = tseed.GetYfit(1) - tseed.GetYref(1);
+ Float_t tquality = (18.0 - tseed.GetN2()) / 2.0 + TMath::Abs(dangle) / 0.1
+ + TMath::Abs(tseed.GetYfit(0) - (tseed.GetYref(0) - zcor)) / 0.2
+ + 2.0 * TMath::Abs(tseed.GetMeanz() - tseed.GetZref(0)) / padlength[jLayer];
squality[jLayer] = tquality;
}
else {
AliTRDpropagationLayer &layer = *(fTrSec[ns]->GetLayer(layers[bLayer][1]-iTime));
Double_t dxlayer = layer.GetX() - xcl[bLayer];
- Double_t zexp = tseed.fZref[0];
- Double_t zcor = tseed.fTilt * (tseed.fZProb - tseed.fZref[0]);
+ Double_t zexp = tseed.GetZref(0);
+ Double_t zcor = tseed.GetTilt() * (tseed.GetZProb() - tseed.GetZref(0));
Float_t roadz = padlength[bLayer] + 1;
- if (TMath::Abs(tseed.fZProb-zexp) > padlength[bLayer]*0.5) {
+ if (TMath::Abs(tseed.GetZProb() - zexp) > 0.5*padlength[bLayer]) {
roadz = padlength[bLayer] * 0.5;
}
- if (tseed.fZfit[1]*tseed.fZref[1] < 0) {
+ if (tseed.GetZfit(1)*tseed.GetZref(1) < 0.0) {
roadz = padlength[bLayer] * 0.5;
}
- if (TMath::Abs(tseed.fZProb-zexp) < 0.1*padlength[bLayer]) {
- zexp = tseed.fZProb;
+ if (TMath::Abs(tseed.GetZProb() - zexp) < 0.1*padlength[bLayer]) {
+ zexp = tseed.GetZProb();
roadz = padlength[bLayer] * 0.5;
}
- Double_t yexp = tseed.fYref[0] + tseed.fYref[1]*dxlayer-zcor;
+ Double_t yexp = tseed.GetYref(0) + tseed.GetYref(1) * dxlayer - zcor;
Int_t index = layer.FindNearestCluster(yexp,zexp,kRoad1y,roadz);
if (index <= 0) {
continue;
}
AliTRDcluster *cl = (AliTRDcluster *) GetCluster(index);
- tseed.fIndexes[iTime] = index;
- tseed.fClusters[iTime] = cl; // Register cluster
- tseed.fX[iTime] = dxlayer; // Register cluster
- tseed.fY[iTime] = cl->GetY(); // Register cluster
- tseed.fZ[iTime] = cl->GetZ(); // Register cluster
+ tseed.SetIndexes(iTime,index);
+ tseed.SetClusters(iTime,cl); // Register cluster
+ tseed.SetX(iTime,dxlayer); // Register cluster
+ tseed.SetY(iTime,cl->GetY()); // Register cluster
+ tseed.SetZ(iTime,cl->GetZ()); // Register cluster
}
tseed.Update();
if (tseed.IsOK()) {
- Float_t dangle = tseed.fYfit[1] - tseed.fYref[1];
- Double_t zcor = tseed.fTilt * (tseed.fZProb - tseed.fZref[0]);
- Float_t tquality = (18.0 - tseed.fN2) / 2.0
- + TMath::Abs(dangle) / 0.1
- + TMath::Abs(tseed.fYfit[0] - (tseed.fYref[0] - zcor)) / 0.2
- + 2.0 * TMath::Abs(tseed.fMeanz - tseed.fZref[0]) / padlength[jLayer];
+ Float_t dangle = tseed.GetYfit(1) - tseed.GetYref(1);
+ Double_t zcor = tseed.GetTilt() * (tseed.GetZProb() - tseed.GetZref(0));
+ Float_t tquality = (18.0 - tseed.GetN2()) / 2.0
+ + TMath::Abs(dangle) / 0.1
+ + TMath::Abs(tseed.GetYfit(0) - (tseed.GetYref(0) - zcor)) / 0.2
+ + 2.0 * TMath::Abs(tseed.GetMeanz() - tseed.GetZref(0)) / padlength[jLayer];
if (tquality<squality[bLayer]) {
bseed[bLayer] = tseed;
}
nlayers = 0;
findable = 0;
for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
- if (TMath::Abs(cseed[iLayer].fYref[0] / cseed[iLayer].fX0) < 0.15) {
+ if (TMath::Abs(cseed[iLayer].GetYref(0) / cseed[iLayer].GetX0()) < 0.15) {
findable++;
}
if (cseed[iLayer].IsOK()) {
- nclusters += cseed[iLayer].fN2;
+ nclusters += cseed[iLayer].GetN2();
nlayers++;
}
}
for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
if (cseed[iLayer].IsOK()) {
rieman.AddPoint(xcl[iLayer]
- ,cseed[iLayer].fYfitR[0]
- ,cseed[iLayer].fZProb
+ ,cseed[iLayer].GetYfitR(0)
+ ,cseed[iLayer].GetZProb()
,1
,10);
}
chi2ZF = 0.0;
for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
if (cseed[iLayer].IsOK()) {
- cseed[iLayer].fYref[0] = rieman.GetYat(xcl[iLayer]);
- chi2RF += (cseed[iLayer].fYref[0] - cseed[iLayer].fYfitR[0])
- * (cseed[iLayer].fYref[0] - cseed[iLayer].fYfitR[0]);
- cseed[iLayer].fYref[1] = rieman.GetDYat(xcl[iLayer]);
- cseed[iLayer].fZref[0] = rieman.GetZat(xcl[iLayer]);
- chi2ZF += (cseed[iLayer].fZref[0] - cseed[iLayer].fMeanz)
- * (cseed[iLayer].fZref[0] - cseed[iLayer].fMeanz);
- cseed[iLayer].fZref[1] = rieman.GetDZat(xcl[iLayer]);
+ cseed[iLayer].SetYref(0,rieman.GetYat(xcl[iLayer]));
+ chi2RF += (cseed[iLayer].GetYref(0) - cseed[iLayer].GetYfitR(0))
+ * (cseed[iLayer].GetYref(0) - cseed[iLayer].GetYfitR(0));
+ cseed[iLayer].SetYref(1,rieman.GetDYat(xcl[iLayer]));
+ cseed[iLayer].SetZref(0,rieman.GetZat(xcl[iLayer]));
+ chi2ZF += (cseed[iLayer].GetZref(0) - cseed[iLayer].GetMeanz())
+ * (cseed[iLayer].GetZref(0) - cseed[iLayer].GetMeanz());
+ cseed[iLayer].SetZref(1,rieman.GetDZat(xcl[iLayer]));
}
}
chi2RF /= TMath::Max((nlayers - 3.0),1.0);
for (Int_t itime = 0; itime < 25; itime++) {
- if (!cseed[iLayer].fUsable[itime]) {
+ if (!cseed[iLayer].IsUsable(itime)) {
continue;
}
// X relative to the middle chamber
- Double_t x = cseed[iLayer].fX[itime] + cseed[iLayer].fX0 - xref2;
- Double_t y = cseed[iLayer].fY[itime];
- Double_t z = cseed[iLayer].fZ[itime];
+ Double_t x = cseed[iLayer].GetX(itime) + cseed[iLayer].GetX0() - xref2;
+ Double_t y = cseed[iLayer].GetY(itime);
+ Double_t z = cseed[iLayer].GetZ(itime);
// ExB correction to the correction
// Tilted rieman
Double_t uvt[6];
// Global x
- Double_t x2 = cseed[iLayer].fX[itime] + cseed[iLayer].fX0;
+ Double_t x2 = cseed[iLayer].GetX(itime) + cseed[iLayer].GetX0();
Double_t t = 1.0 / (x2*x2 + y*y);
uvt[1] = t; // t
uvt[0] = 2.0 * x2 * uvt[1]; // u
//
// Constrained rieman
//
- z = cseed[iLayer].fZ[itime];
+ z = cseed[iLayer].GetZ(itime);
uvt[0] = 2.0 * x2 * t; // u
uvt[1] = 2.0 * hL[iLayer] * x2 * uvt[1];
uvt[2] = 2.0 * (y + hL[iLayer] * (z - GetZ())) * t;
for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
if (cseed[iLayer].IsOK()) {
Double_t zT2 = rpolz0 + rpolz1 * (xcl[iLayer] - xref2);
- if (TMath::Abs(cseed[iLayer].fZProb - zT2) > padlength[iLayer] * 0.5 + 1.0) {
+ if (TMath::Abs(cseed[iLayer].GetZProb() - zT2) > padlength[iLayer] * 0.5 + 1.0) {
acceptablez = kFALSE;
}
}
if (cseed[iLayer].IsOK()) {
Double_t zT2 = rpolz0 + rpolz1 * (xcl[iLayer] - xref2);
Double_t zTC = polz0c + polz1c * (xcl[iLayer] - xref2);
- chi2ZT2 += TMath::Abs(cseed[iLayer].fMeanz - zT2);
- chi2ZTC += TMath::Abs(cseed[iLayer].fMeanz - zTC);
+ chi2ZT2 += TMath::Abs(cseed[iLayer].GetMeanz() - zT2);
+ chi2ZTC += TMath::Abs(cseed[iLayer].GetMeanz() - zTC);
}
}
chi2ZT2 /= TMath::Max((nlayers - 3.0),1.0);
Float_t sumdaf = 0.0;
for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
if (cseed[iLayer].IsOK()) {
- sumdaf += TMath::Abs((cseed[iLayer].fYfit[1] - cseed[iLayer].fYref[1])
- / cseed[iLayer].fSigmaY2);
+ sumdaf += TMath::Abs((cseed[iLayer].GetYfit(1) - cseed[iLayer].GetYref(1))
+ / cseed[iLayer].GetSigmaY2());
}
}
sumdaf /= Float_t (nlayers - 2.0);
index0 = 2;
}
}
- seedparams[registered][0] = cseed[index0].fX0;
- seedparams[registered][1] = cseed[index0].fYref[0];
- seedparams[registered][2] = cseed[index0].fZref[0];
+ seedparams[registered][0] = cseed[index0].GetX0();
+ seedparams[registered][1] = cseed[index0].GetYref(0);
+ seedparams[registered][2] = cseed[index0].GetZref(0);
seedparams[registered][5] = cR;
- seedparams[registered][3] = cseed[index0].fX0 * cR - TMath::Sin(TMath::ATan(cseed[0].fYref[1]));
- seedparams[registered][4] = cseed[index0].fZref[1]
- / TMath::Sqrt(1.0 + cseed[index0].fYref[1] * cseed[index0].fYref[1]);
+ seedparams[registered][3] = cseed[index0].GetX0() * cR - TMath::Sin(TMath::ATan(cseed[0].GetYref(1)));
+ seedparams[registered][4] = cseed[index0].GetZref(1)
+ / TMath::Sqrt(1.0 + cseed[index0].GetYref(1) * cseed[index0].GetYref(1));
seedparams[registered][6] = ns;
Int_t labels[12];
if (!cseed[iLayer].IsOK()) {
continue;
}
- if (cseed[iLayer].fLabels[0] >= 0) {
- labels[nlab] = cseed[iLayer].fLabels[0];
+ if (cseed[iLayer].GetLabels(0) >= 0) {
+ labels[nlab] = cseed[iLayer].GetLabels(0);
nlab++;
}
- if (cseed[iLayer].fLabels[1] >= 0) {
- labels[nlab] = cseed[iLayer].fLabels[1];
+ if (cseed[iLayer].GetLabels(1) >= 0) {
+ labels[nlab] = cseed[iLayer].GetLabels(1);
nlab++;
}
}
Int_t label = outlab[0];
Int_t frequency = outlab[1];
for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
- cseed[iLayer].fFreq = frequency;
- cseed[iLayer].fC = cR;
- cseed[iLayer].fCC = cC;
- cseed[iLayer].fChi2 = chi2TR;
- cseed[iLayer].fChi2Z = chi2ZF;
+ cseed[iLayer].SetFreq(frequency);
+ cseed[iLayer].SetC(cR);
+ cseed[iLayer].SetCC(cC);
+ cseed[iLayer].SetChi2(chi2TR);
+ cseed[iLayer].SetChi2Z(chi2ZF);
}
// Debugging print
for (Int_t jLayer = 0; jLayer < 6; jLayer++) {
- if (TMath::Abs(seed[index][jLayer].fYref[0] / xcl[jLayer]) < 0.15) {
+ if (TMath::Abs(seed[index][jLayer].GetYref(0) / xcl[jLayer]) < 0.15) {
findable++;
}
if (seed[index][jLayer].IsOK()) {
seed[index][jLayer].UpdateUsed();
- ncl +=seed[index][jLayer].fN2;
- nused +=seed[index][jLayer].fNUsed;
+ ncl +=seed[index][jLayer].GetN2();
+ nused +=seed[index][jLayer].GetNUsed();
nlayers++;
// Cooking label
for (Int_t itime = 0; itime < 25; itime++) {
- if (seed[index][jLayer].fUsable[itime]) {
+ if (seed[index][jLayer].IsUsable(itime)) {
naccepted++;
for (Int_t ilab = 0; ilab < 3; ilab++) {
- Int_t tindex = seed[index][jLayer].fClusters[itime]->GetLabel(ilab);
+ Int_t tindex = seed[index][jLayer].GetClusters(itime)->GetLabel(ilab);
if (tindex >= 0) {
labelsall[nlabelsall] = tindex;
nlabelsall++;
Int_t nlab = 0;
for (Int_t iLayer = 0; iLayer < 6; iLayer++) {
if (seed[index][iLayer].IsOK()) {
- if (seed[index][iLayer].fLabels[0] >= 0) {
- labels[nlab] = seed[index][iLayer].fLabels[0];
+ if (seed[index][iLayer].GetLabels(0) >= 0) {
+ labels[nlab] = seed[index][iLayer].GetLabels(0);
nlab++;
}
- if (seed[index][iLayer].fLabels[1] >= 0) {
- labels[nlab] = seed[index][iLayer].fLabels[1];
+ if (seed[index][iLayer].GetLabels(1) >= 0) {
+ labels[nlab] = seed[index][iLayer].GetLabels(1);
nlab++;
}
}
if (ratio < 0.25) {
for (Int_t jLayer = 0; jLayer < 6; jLayer++) {
if ((seed[index][jLayer].IsOK()) &&
- (TMath::Abs(seed[index][jLayer].fYfit[1] - seed[index][jLayer].fYfit[1]) < 0.2)) {
+ (TMath::Abs(seed[index][jLayer].GetYfit(1) - seed[index][jLayer].GetYfit(1)) < 0.2)) {
seed[index][jLayer].UseClusters(); // Sign gold
}
}
Int_t index = t->GetClusterIndex(i);
AliTRDcluster *c = (AliTRDcluster *) fClusters->UncheckedAt(index);
Int_t iplane = fGeom->GetPlane(c->GetDetector());
- if (track->fTracklets[iplane].GetChi2() > kmaxchi2) {
+ if (track->GetTracklets(iplane).GetChi2() > kmaxchi2) {
continue;
}
- if (track->fTracklets[iplane].GetN() < kmincl) {
+ if (track->GetTracklets(iplane).GetN() < kmincl) {
continue;
}
if (!(c->IsUsed())) {
// AliTRDtrackingSector Constructor
//
- AliTRDpadPlane *padPlane = 0;
- AliTRDpropagationLayer *ppl = 0;
+ AliTRDpadPlane *padPlane = 0;
+ AliTRDpropagationLayer *ppl = 0;
// Get holes description from geometry
Bool_t holes[AliTRDgeometry::kNcham];
}
dx = AliTRDcalibDB::Instance()->GetVdrift(0,0,0)
- / AliTRDcalibDB::Instance()->GetSamplingFrequency();
+ / commonParam->GetSamplingFrequency();
rho = 0.00295 * 0.85; //????
radLength = 11.0;
if (road > 6.0) {
road = 6.0;
}
+ //road = 20.0;
for (Int_t it = 0; it < t1-t0; it++) {
//
// Find 2 nearest cluster at given time bin
//
+ int checkPoint[4] = {0,0,0,0};
+ double minY = 123456789;
+ double minD[2] = {1,1};
+
for (Int_t i = timeBin.Find(y - road); i < maxn; i++) {
+ //for (Int_t i = 0; i < maxn; i++) {
AliTRDcluster *c = (AliTRDcluster *) (timeBin[i]);
h01 = GetTiltFactor(c);
plane = fGeom->GetPlane(det);
padlength = TMath::Sqrt(c->GetSigmaZ2() * 12.0);
}
+
//if (c->GetLocalTimeBin()==0) continue;
if (c->GetY() > (y + road)) {
break;
}
- if ((c->GetZ() - z) * (c->GetZ() - z) > (12.0 * sz2)) {
+
+ fHDeltaX->Fill(c->GetX() - x[it]);
+ //printf("%f\t%f\t%f \n", c->GetX(), x[it], c->GetX()-x[it]);
+
+ if (TMath::Abs(c->GetY()-y) < TMath::Abs(minY)) {
+ minY = c->GetY()-y;
+ minD[0] = c->GetY()-y;
+ minD[1] = c->GetZ()-z;
+ }
+
+ checkPoint[0]++;
+
+ fHMinZ->Fill(c->GetZ() - z);
+ if ((c->GetZ() - z) * (c->GetZ() - z) > 2 * (12.0 * sz2)) {
continue;
}
+ checkPoint[1]++;
Double_t dist = TMath::Abs(c->GetZ() - z);
- if (dist > (0.5 * padlength + 6.0 * sigmaz)) {
+ if (dist > (0.5 * padlength + 6.0 * sigmaz)) { // 0.5
continue; // 6 sigma boundary cut
}
+ checkPoint[2]++;
+
Double_t cost = 0.0;
// Sigma boundary cost function
if (dist> (0.5 * padlength - sigmaz)){
if (chi2 > maxChi2[1]) {
continue;
}
+ checkPoint[3]++;
+
detector = c->GetDetector();
// Store the clusters in the road
for (Int_t ih = 2; ih < 9; ih++) {
indexes[1][it] = timeBin.GetIndex(i);
}
+
+ for(int iCheckPoint = 0; iCheckPoint<4; iCheckPoint++)
+ fHFindCl[iCheckPoint]->Fill(checkPoint[iCheckPoint]);
+
+ if (checkPoint[3]) {
+ if (track->GetPt() > 0) fHMinYPos->Fill(minY);
+ else fHMinYNeg->Fill(minY);
+
+ fHMinD->Fill(minD[0], minD[1]);
+ }
if (cl[0][it]) {
nfound++;
mean[it] = 0.0; // Mean value
angle[it] = 0.0; // Angle
- smoffset[it] = 1.0e10; // Sigma of mean offset
- smean[it] = 1.0e10; // Sigma of mean value
- sangle[it] = 1.0e10; // Sigma of angle
+ smoffset[it] = 1.0e5; // Sigma of mean offset
+ smean[it] = 1.0e5; // Sigma of mean value
+ sangle[it] = 1.0e5; // Sigma of angle
smeanangle[it] = 0.0; // Correlation
- sigmas[it] = 1.0e10;
- tchi2s[it] = 1.0e10; // Chi2s for tracklet
+ sigmas[it] = 1.0e5;
+ tchi2s[it] = 1.0e5; // Chi2s for tracklet
}
//if (tchi2s[bestiter]>25.) sigma2*=tchi2s[bestiter]/25.;
//if (tchi2s[bestiter]>25.) sigma2=1000.; // dont'accept
- Double_t exB = AliTRDcalibDB::Instance()->GetOmegaTau(
- AliTRDcalibDB::Instance()->GetVdrift(0,0,0));
+ Double_t exB = AliTRDcalibDB::Instance()->GetOmegaTau(AliTRDcalibDB::Instance()->GetVdrift(0,0,0)
+ ,-AliTracker::GetBz()*0.1);
Double_t expectederr = sigma2*sigma2 + 0.01*0.01;
if (mpads > 3.5) {
expectederr += (mpads - 3.5) * 0.04;
tracklet.SetSigma2(expectederr);
tracklet.SetChi2(tchi2s[bestiter]);
tracklet.SetMaxPos(maxpos,maxpos4,maxpos5);
- track->fTracklets[plane] = tracklet;
- track->fNWrong += nbad[0];
+ track->SetTracklets(plane,tracklet);
+ track->SetNWrong(track->GetNWrong() + nbad[0]);
//
// Debuging part
for (Int_t ilayer = 0; ilayer < 6; ilayer++) {
if (seeds[ilayer].IsOK()) {
for (Int_t itime = 22; itime > 0; itime--) {
- if (seeds[ilayer].fIndexes[itime] > 0) {
- index = seeds[ilayer].fIndexes[itime];
- cl = seeds[ilayer].fClusters[itime];
+ if (seeds[ilayer].GetIndexes(itime) > 0) {
+ index = seeds[ilayer].GetIndexes(itime);
+ cl = seeds[ilayer].GetClusters(itime);
break;
}
}
}
return track;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+void AliTRDtracker::InitLogHists() {
+
+ fHBackfit = new TH1D("logTRD_backfit", "", 40, -0.5, 39.5);
+ fHRefit = new TH1D("logTRD_refit", "", 40, -0.5, 39.5);
+ fHClSearch = new TH1D("logTRD_clSearch", "", 60, -0.5, 59.5);
+
+ fHX = new TH1D("logTRD_X", ";x (cm)", 200, 50, 400);
+ fHNCl = new TH1D("logTRD_ncl", "", 40, -0.5, 39.5);
+ fHNClTrack = new TH1D("logTRD_nclTrack", "", 180, -0.5, 179.5);
+
+ fHMinYPos = new TH1D("logTRD_minYPos", ";#delta Y (cm)", 400, -6, 6);
+ fHMinYNeg = new TH1D("logTRD_minYNeg", ";#delta Y (cm)", 400, -6, 6);
+ fHMinZ = new TH1D("logTRD_minZ", ";#delta Z (cm)", 400, -20, 20);
+ fHMinD = new TH2D("logTRD_minD", ";#delta Y (cm);#delta Z (cm)", 100, -6, 6, 100, -50, 50);
+
+ fHDeltaX = new TH1D("logTRD_deltaX", ";#delta X (cm)", 100, -5, 5);
+ fHXCl = new TH1D("logTRD_xCl", ";cluster x position (cm)", 1000, 280, 380);
+
+ const char *nameFindCl[4] = {"logTRD_clY", "logTRD_clZ", "logTRD_clB", "logTRD_clG"};
+
+ for(int i=0; i<4; i++) {
+ fHFindCl[i] = new TH1D(nameFindCl[i], "", 30, -0.5, 29.5);
+ }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+void AliTRDtracker::SaveLogHists() {
+
+ TDirectory *sav = gDirectory;
+ TFile *logFile = 0;
+
+ TSeqCollection *col = gROOT->GetListOfFiles();
+ int N = col->GetEntries();
+ for(int i=0; i<N; i++) {
+ logFile = (TFile*)col->At(i);
+ if (strstr(logFile->GetName(), "AliESDs.root")) break;
+ }
+
+ logFile->cd();
+ fHBackfit->Write(fHBackfit->GetName(), TObject::kOverwrite);
+ fHRefit->Write(fHRefit->GetName(), TObject::kOverwrite);
+ fHClSearch->Write(fHClSearch->GetName(), TObject::kOverwrite);
+ fHX->Write(fHX->GetName(), TObject::kOverwrite);
+ fHNCl->Write(fHNCl->GetName(), TObject::kOverwrite);
+ fHNClTrack->Write(fHNClTrack->GetName(), TObject::kOverwrite);
+
+ fHMinYPos->Write(fHMinYPos->GetName(), TObject::kOverwrite);
+ fHMinYNeg->Write(fHMinYNeg->GetName(), TObject::kOverwrite);
+ fHMinD->Write(fHMinD->GetName(), TObject::kOverwrite);
+ fHMinZ->Write(fHMinZ->GetName(), TObject::kOverwrite);
+
+ fHDeltaX->Write(fHDeltaX->GetName(), TObject::kOverwrite);
+ fHXCl->Write(fHXCl->GetName(), TObject::kOverwrite);
+
+ for(int i=0; i<4; i++)
+ fHFindCl[i]->Write(fHFindCl[i]->GetName(), TObject::kOverwrite);
+
+ logFile->Flush();
+
+ sav->cd();
}
+
+//////////////////////////////////////////////////////////////////////////////////////////
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff