--- /dev/null
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// AliBarrelTrack is a snapshot of the TPC or TRD track.
+// The barrel track is stored by tracker every time a track is crossing
+// reference plane.
+//
+// Barrel track have
+// - state vactor in "external represenantion"
+// - diagonal elements of covariance matric
+// - auxiliary paramrters:
+// chi2, number of clusters, number of sector srossed
+// - methods to compare with track references
+//
+// Barrel track can be directly compared with AliTrackReferences,
+// TPC and TRD tracks can be compared using the same macro.
+//
+// S. Radomski, [GSI] mail: S.Radomski@gsi.de
+// 07.04.2003
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include "AliBarrelTrack.h"
+
+ClassImp(AliBarrelTrack)
+
+////////////////////////////////////////////////////////////////////////////////
+
+AliBarrelTrack:: AliBarrelTrack() : TObject() {
+ //
+ // Standard constructor
+ // reset all data-members
+ //
+
+ fLabel = fRefPlane = fIsIn = 0;
+ fX = fAlpha = 0.0;
+ fZ = fY = fTgLambda = fSnPhi = f1Pt = 0.0;
+
+ for(Int_t i=0; i<5; i++) fTimeHypothesis[i] = 0;
+
+ fLength = 0.0;
+ fNClusters = fNWrong = fNRotate = 0;
+ fChi2 = 0.0;
+ fMass = fdEdX = 0;
+
+ fCy = fCz = fCtg = fCpt = fCphi = 0.0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetLabel(Int_t label) {
+ //
+ // Sets the label
+ //
+
+ fLabel = label;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetX(Double_t x, Double_t alpha) {
+ //
+
+ fX = x;
+ fAlpha = alpha;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetRefPlane(Int_t nRefPlane, Int_t isIn) {
+
+ fRefPlane = nRefPlane;
+ fIsIn = isIn;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetNClusters(Int_t nClusters, Double_t chi2) {
+
+ fNClusters = nClusters;
+ fChi2 = chi2;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetTime(Float_t time[5], Double_t length) {
+
+ for(Int_t i=0; i<5; i++)
+ fTimeHypothesis[i] = time[i];
+
+ fLength = length;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetStateVector(Double_t vec[5]) {
+ //
+ // Set State Vector from external representation
+ //
+
+
+ fY = vec[0];
+ fZ = vec[1];
+ fTgLambda = vec[3];
+ fSnPhi = vec[2];
+ f1Pt = vec[4];
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AliBarrelTrack::SetCovarianceMatrix(Double_t vec[15]) {
+ //
+ // Set Covariance Matrix from external represenatation
+ //
+
+ fCy = vec[0];
+ fCz = vec[2];
+ fCtg = vec[9];
+ fCphi = vec[5];
+ fCpt = vec[14];
+}
+
+////////////////////////////////////////////////////////////////////////////////
--- /dev/null
+
+#ifndef AliBarrelTrack_H
+#define AliBarrelTrack_H
+
+#include "TObject.h"
+#include "TMath.h"
+
+class AliBarrelTrack : public TObject {
+
+ protected:
+
+ Int_t fLabel; // kine tree index
+
+ Int_t fRefPlane; // id of the reference plane
+ Int_t fIsIn; // direction
+
+ Double_t fX; // Kalman Time
+ Double_t fAlpha; // sector angle
+
+ // state vector
+ Double_t fZ; // Z in global cs
+ Double_t fY; // Y in local cs corresponds to r-phi
+ Double_t fTgLambda; // Tangent of the dip angle
+ Double_t fSnPhi; // Sin
+ Double_t f1Pt; // inverse of momentum
+
+
+ // covariance matrix
+ Double_t fCz;
+ Double_t fCy;
+ Double_t fCtg;
+ Double_t fCphi;
+ Double_t fCpt;
+
+
+ // track time/length
+ Double_t fTimeHypothesis[5]; // time for all hypoptheses
+ Double_t fLength; // track length
+
+ // performance info
+ Int_t fNClusters; // Number of clusters
+ Int_t fNWrong; // Number of wrong clusters
+ Double_t fChi2; // Chi 2
+ Int_t fNRotate; // number of rotations / sector crossing
+
+ Double_t fMass; // mass hypothesis
+ Double_t fdEdX; // dE/dX
+
+ public:
+
+ AliBarrelTrack();
+ ~AliBarrelTrack() {}
+
+ // Setters
+
+ void SetLabel(Int_t label);
+ void SetX(Double_t x, Double_t alpha);
+ void SetRefPlane(Int_t nRefPlane, Int_t isIn);
+ void SetNClusters(Int_t nClusters, Double_t chi2);
+ void SetTime(Float_t time[5], Double_t length);
+ void SetStateVector(Double_t vec[5]); // external parameters
+ void SetCovarianceMatrix(Double_t vec[15]); // external parameters
+
+ void SetNWrongClusters(Int_t n) {fNWrong = n;}
+ void SetNRotate(Int_t n) {fNRotate = n;}
+
+ void SetMass(Double_t mass) {fMass = mass;}
+ void SetdEdX(Double_t dEdX) {fdEdX = dEdX;}
+
+ // Getters
+
+ // standard
+ Int_t GetLabel() const {return fLabel;}
+ Int_t GetNClusters() const {return fNClusters;}
+ Int_t GetNWrongClusters() const {return fNWrong;}
+ Int_t GetNRotate() const {return fNRotate;}
+
+ Int_t GetRefPlane() const {return fRefPlane;}
+
+ Double_t GetX() const {return fX;}
+ Double_t Y() const {return fY;}
+ Double_t Z() const {return fZ;}
+
+ Double_t GetMass() const {return fMass;}
+
+ // track oriented variables
+ Double_t Pt() const {return (f1Pt==0)? 0 : 1./f1Pt;}
+ Double_t TgLambda() const {return fTgLambda;}
+ Double_t Eta() const {return -TMath::Log(TMath::Tan(0.25 *TMath::Pi()-0.5*Lambda()));}
+ Double_t Phi() const {return TMath::ASin(fSnPhi);}
+
+
+ // uncertainties
+ Double_t DeltaY() const {return TMath::Sqrt(fCy);}
+ Double_t DeltaZ() const {return TMath::Sqrt(fCz);}
+ Double_t DeltaTgLambda() const {return TMath::Sqrt(fCtg);}
+ Double_t DeltaSnPhi() const {return TMath::Sqrt(fCphi);}
+ Double_t DeltaPt() const {return Pt() - 1./(Pt() + TMath::Sqrt(fCpt));}
+
+
+ // reference oriented variables
+ Double_t Px() const {return TMath::Cos(Phi()+fAlpha) * Pt();}
+ Double_t Py() const {return TMath::Sin(Phi()+fAlpha) * Pt();}
+ Double_t Pz() const {return fTgLambda*Pt();}
+ Double_t P() const {return Pt()*(fTgLambda+1);}
+
+ Double_t Lambda() const {return TMath::ATan(fTgLambda);}
+
+ ClassDef(AliBarrelTrack,1)
+};
+
+
+#endif
protected:
+
void SetChi2(Double_t chi2) {fChi2=chi2;}
void SetMass(Double_t mass) {fMass=mass;}
void SetNumberOfClusters(Int_t n) {fN=n;}
-private:
Int_t fLab; // track label
Double_t fChi2; // total chi2 value for this track
Double_t fMass; // mass hypothesis
Bool_t fStartTimeIntegral; // indicator wether integrate time
Float_t fIntegratedTime[5]; // intgrated time
Float_t fIntegratedLength; // integrated length
+
+ public:
ClassDef(AliKalmanTrack,2) // Reconstructed track
};
virtual void SetPosition(Float_t x, Float_t y, Float_t z){fX=x; fY=y; fZ=z;}
virtual void SetMomentum(Float_t px, Float_t py, Float_t pz){fPx=px; fPy=py; fPz=pz;}
+ // Methods to get position of the track reference in
+ // in the TPC/TRD/TOF Tracking coordinate system
+
+ virtual Float_t PhiPos() const {return TMath::Pi()+TMath::ATan2(-fY, -fX);}
+ virtual Float_t Alpha() const
+ {return TMath::Pi()*(20*((((Int_t)(PhiPos()*180/TMath::Pi()))/20))+10)/180.;}
+ virtual Float_t LocalX() const {return fX*TMath::Cos(-Alpha()) - fY*TMath::Sin(-Alpha());}
+ virtual Float_t LocalY() const {return fX*TMath::Sin(-Alpha()) + fY*TMath::Cos(-Alpha());}
+
protected:
Int_t fTrack; // Track number
class TFile;
class AliTracker : public TObject {
+
+
public:
- AliTracker() { fX=fY=fZ=0.; fSigmaX=fSigmaY=fSigmaZ=0.; fEventN=0; }
+
+ enum {kTrackInward, kTrackBack, kTrackRefit} Propagation_t;
+
+ AliTracker() { fX=fY=fZ=0.; fSigmaX=fSigmaY=fSigmaZ=0.; fEventN=0; fStoreBarrel = 1;}
virtual ~AliTracker(){}
virtual Int_t Clusters2Tracks(const TFile *in, TFile *out)=0;
virtual Int_t PropagateBack(const TFile *in, TFile *out)=0;
}
void SetEventNumber(Int_t ev) { fEventN=ev; }
+
+
//protected:
virtual Int_t LoadClusters()=0;
virtual void UnloadClusters()=0;
static Int_t SetFieldFactor(TFile* file, Bool_t deletegAlice = kTRUE);
static Int_t SetFieldFactor();
+ Int_t IsStoringBarrel() const {return fStoreBarrel;}
+ void SetStoreBarrel(Int_t s) {fStoreBarrel = s;}
+
private:
Int_t fEventN;//event number
+ Int_t fStoreBarrel;
+
Double_t fX; //X-coordinate of the primary vertex
Double_t fY; //Y-coordinate of the primary vertex
Double_t fZ; //Z-coordinate of the primary vertex
#pragma link C++ class AliTrackMapper+;
#pragma link C++ class AliCollisionGeometry+;
#pragma link C++ class AliMemoryWatcher+;
+#pragma link C++ class AliBarrelTrack+;
#endif
AliMergeCombi.cxx AliMagFMaps.cxx AliFieldMap.cxx \
AliGausCorr.cxx AliTrackReference.cxx AliESD.cxx \
AliTrackMap.cxx AliTrackMapper.cxx AliCollisionGeometry.cxx \
-AliMemoryWatcher.cxx
+AliMemoryWatcher.cxx AliBarrelTrack.cxx
HDRS:= $(SRCS:.cxx=.h)
/*
$Log$
+Revision 1.19 2003/03/03 16:56:53 hristov
+Corrections to obey coding conventions
+
Revision 1.18 2003/02/19 08:57:04 hristov
Control^M removed
#include "AliTPCtrack.h"
#include "AliCluster.h"
+#include "AliBarrelTrack.h"
ClassImp(AliTPCtrack)
{
fX = fP0 = fP1 = fP2 = fP3 = fP3 = fP4 = 0.0;
fAlpha = fdEdx = 0.0;
+ fNWrong = fNRotation = fNumber = 0; // [SR, 01.04.2003]
}
//_________________________________________________________________________
Int_t n=GetNumberOfClusters();
for (Int_t i=0; i<n; i++) fIndex[i]=t.fIndex[i];
}
+//_____________________________________________________________________________
+
+void AliTPCtrack::GetBarrelTrack(AliBarrelTrack *track) {
+ //
+ // Create a Barrel Track out of this track
+ // Current track is propagated to the reference plane
+ // by the tracker
+ //
+ // [SR, 01.04.2003]
+
+ if (!track) return;
+ Double_t xr, vec[5], cov[15];
+
+ track->SetLabel(GetLabel());
+ track->SetX(fX, fAlpha);
+ track->SetNClusters(GetNumberOfClusters(), GetChi2());
+ track->SetTime(fIntegratedTime, fIntegratedLength);
+
+ track->SetMass(fMass);
+ track->SetdEdX(fdEdx);
+
+ track->SetNWrongClusters(fNWrong);
+ track->SetNRotate(fNRotation);
+ GetExternalParameters(xr, vec);
+ track->SetStateVector(vec);
+
+ GetExternalCovariance(cov);
+ track->SetCovarianceMatrix(cov);
+
+}
//_____________________________________________________________________________
Int_t AliTPCtrack::Compare(const TObject *o) const {
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// This function associates a cluster with this track.
//-----------------------------------------------------------------
+
+ // update the number of wrong SR[20.03.2003]
+ Int_t absLabel = TMath::Abs(GetLabel());
+ if ( (c->GetLabel(0) != absLabel) &&
+ (c->GetLabel(0) != absLabel) &&
+ (c->GetLabel(0) != absLabel)) fNWrong++;
+ //
+
Double_t r00=c->GetSigmaY2(), r01=0., r11=c->GetSigmaZ2();
r00+=fC00; r01+=fC10; r11+=fC11;
Double_t det=r00*r11 - r01*r01;
//-----------------------------------------------------------------
// This function rotates this track.
//-----------------------------------------------------------------
+
+ if (alpha != 0) fNRotation++; // [SR, 01.04.2003]
+
fAlpha += alpha;
if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
if (fAlpha>=TMath::Pi()) fAlpha -= 2*TMath::Pi();
#include "AliTPCreco.h"
+class AliBarrelTrack;
+
//_____________________________________________________________________________
class AliTPCtrack : public AliKalmanTrack {
public:
void GetExternalParameters(Double_t& xr, Double_t x[5]) const ;
void GetExternalCovariance(Double_t cov[15]) const ;
+ // [SR, 01.04.2003]
+
+ void GetBarrelTrack(AliBarrelTrack *track);
+
+ void ResetNWrong() {fNWrong = 0;}
+ void ResetNRotation() {fNRotation = 0;}
+
+ Int_t GetNWrong() const {return fNWrong;}
+ Int_t GetNRotation() const {return fNRotation;}
+
+ Int_t GetNumber() const {return fNumber;}
+ void SetNumber(Int_t n) {fNumber = n;}
+ //
+
Int_t GetClusterIndex(Int_t i) const {return fIndex[i];}
//******** To be removed next release !!! **************
UInt_t fIndex[kMaxRow]; // indices of associated clusters
+ //[SR, 01.04.2003]
+ Int_t fNWrong; // number of wrong clusters
+ Int_t fNRotation; // number of rotations
+ Int_t fNumber; // magic number used for number of clusters
+
ClassDef(AliTPCtrack,1) // Time Projection Chamber reconstructed tracks
};
/*
$Log$
+Revision 1.31 2003/03/19 17:14:11 hristov
+Load/UnloadClusters added to the base class and the derived classes changed correspondingly. Possibility to give 2 input files for ITS and TPC tracks in PropagateBack. TRD tracker uses fEventN from the base class (T.Kuhr)
+
Revision 1.30 2003/02/28 16:13:32 hristov
Typos corrected
fParam = (AliTPCParam*) par;
fSeeds=0;
+
+ // [SR 17.03.2003]
+
+ fBarrelFile = 0;
+ fBarrelTree = 0;
+ fBarrelArray = 0;
+ fBarrelTrack = 0;
+
}
//_____________________________________________________________________________
fSeeds->Delete();
delete fSeeds;
}
+
+ // [SR, 01.04.2003]
+ if (fBarrelFile) {
+ fBarrelFile->Close();
+ delete fBarrelFile;
+ }
+}
+
+//_____________________________________________________________________________
+
+void AliTPCtracker::SetBarrelTree(const char *mode) {
+ //
+ // Creates a tree for BarrelTracks
+ // mode = "back" or "refit"
+ //
+ // [SR, 01.04.2003]
+ //
+
+ if (!IsStoringBarrel()) return;
+
+ TDirectory *sav = gDirectory;
+ if (!fBarrelFile) fBarrelFile = new TFile("AliBarrelTracks.root", "UPDATE");
+
+ char buff[40];
+ sprintf(buff, "BarrelTPC_%d_%s", GetEventNumber(), mode);
+
+ fBarrelFile->cd();
+ fBarrelTree = new TTree(buff, "Barrel TPC tracks");
+
+ if (!fBarrelArray) fBarrelArray = new TClonesArray("AliBarrelTrack", 4);
+ for(Int_t i=0; i<4; i++) new((*fBarrelArray)[i]) AliBarrelTrack();
+
+ fBarrelTree->Branch("tracks", &fBarrelArray);
+
+ sav->cd();
+}
+//_____________________________________________________________________________
+
+void AliTPCtracker::StoreBarrelTrack(AliTPCtrack *ps, Int_t refPlane, Int_t isIn) {
+ //
+ // Stores Track at a given reference plane
+ //
+ // refPlane: 1-4
+ // isIn: 1 - backward, 2 - refit
+ //
+
+ if (!IsStoringBarrel()) return;
+ if (refPlane < 0 || refPlane > 4) return;
+ if (isIn > 2) return;
+
+ static Int_t nClusters;
+ static Int_t nWrong;
+ static Double_t chi2;
+ static Int_t index;
+
+ Int_t newClusters, newWrong;
+ Double_t newChi2;
+
+ if ( (refPlane == 1 && isIn == kTrackBack) ||
+ (refPlane == 4 && isIn == kTrackRefit) ) {
+
+ fBarrelArray->Clear();
+ nClusters = nWrong = 0;
+ chi2 = 0.0;
+ index = 0;
+ }
+
+ // propagate
+ Double_t refX = 0;
+ if (refPlane == 1) refX = fParam->GetInnerRadiusLow();
+ if (refPlane == 2) refX = fParam->GetInnerRadiusUp();
+ if (refPlane == 3) refX = fParam->GetOuterRadiusLow();
+ if (refPlane == 4) refX = fParam->GetOuterRadiusUp();
+
+ ps->PropagateTo(refX);
+
+ fBarrelTrack = (AliBarrelTrack*)(*fBarrelArray)[index++];
+ ps->GetBarrelTrack(fBarrelTrack);
+
+ newClusters = ps->GetNumberOfClusters() - nClusters;
+ newWrong = ps->GetNWrong() - nWrong;
+ newChi2 = ps->GetChi2() - chi2;
+
+ nClusters = ps->GetNumberOfClusters();
+ nWrong = ps->GetNWrong();
+ chi2 = ps->GetChi2();
+
+ fBarrelTrack->SetNClusters(newClusters, newChi2);
+ fBarrelTrack->SetNWrongClusters(newWrong);
+ fBarrelTrack->SetRefPlane(refPlane, isIn);
}
//_____________________________________________________________________________
return 0;
}
+ //if (fSectors == fInnerSec && (nr == 63 || nr == 0)) {
+ // cout << nr << "\t" << krow << endl;
+ //}
+
if (krow) {
for (Int_t i=krow.Find(y-road); i<krow; i++) {
AliTPCcluster *c=(AliTPCcluster*)(krow[i]);
Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) {
//
// This function propagates seed inward TPC using old clusters
- // from track.
+ // from the track.
//
// Sylwester Radomski, GSI
// 26.02.2003
Int_t s=Int_t(alpha/fSectors->GetAlpha())%fN;
Int_t idx=-1, sec=-1, row=-1;
- Int_t nc = seed->GetLabel(); // index to start with
+ Int_t nc = seed->GetNumber();
idx=track->GetClusterIndex(nc);
sec=(idx&0xff000000)>>24;
else { if (sec < fkNIS) row=-1; }
Int_t nr=fSectors->GetNRows();
- for (Int_t i=0; i<nr; i++) {
+ for (Int_t i=nr-1; i>=0; i--) {
+
+ //cout << endl;
+ //cout << i << "\t" << nc << "\t"<< row << "\t" << seed->Pt() << "\t" << track->Pt() << "\t\t";
Double_t x=fSectors->GetX(i);
if (!seed->PropagateTo(x)) return 0;
Int_t index = 0;
Double_t maxchi2 = kMaxCHI2;
- //cout << i << " " << row << " " << nc << endl;
-
if (row==i) {
+ //cout << row << endl;
// accept already found cluster
AliTPCcluster *c=(AliTPCcluster*)GetCluster(idx);
Double_t chi2 = seed->GetPredictedChi2(c);
cl=c;
maxchi2=chi2;
- if (++nc < track->GetNumberOfClusters() ) {
+ //cout << c->GetY() << "\t" << seed->GetY() << "\t" << track->GetY();
+
+ if (--nc >= 0 /* track->GetNumberOfClusters()*/ ) {
idx=track->GetClusterIndex(nc);
sec=(idx&0xff000000)>>24;
row=(idx&0x00ff0000)>>16;
}
if (cl) {
-
- //cout << "Assigned" << endl;
Float_t l=fSectors->GetPadPitchWidth();
Float_t corr=1.; if (i>63) corr=0.67; // new (third) pad response !
seed->SetSampledEdx(cl->GetQ()/l*corr,seed->GetNumberOfClusters());
}
}
- seed->SetLabel(nc);
+ seed->SetNumber(nc);
return 1;
}
Int_t s=Int_t(alpha/fSectors->GetAlpha())%fN;
Int_t idx=-1, sec=-1, row=-1;
- Int_t nc=seed.GetLabel(); //index of the cluster to start with
+ //Int_t nc=seed.GetLabel(); //index of the cluster to start with
+ Int_t nc=seed.GetNumber();
+
if (nc--) {
idx=track.GetClusterIndex(nc);
sec=(idx&0xff000000)>>24; row=(idx&0x00ff0000)>>16;
for (Int_t i=0; i<nr; i++) {
Double_t x=fSectors->GetX(i), ymax=fSectors->GetMaxY(i);
+ //cout << i << "\t" << nc << "\t" << row << "\t" << track.GetNumberOfClusters() << endl;
+
if (!seed.PropagateTo(x)) return 0;
Double_t y=seed.GetY();
return 0;
}
-
Int_t accepted=seed.GetNumberOfClusters();
if (row==i) {
+
+ //if (fSectors == fInnerSec && row == 0)
+ //cout << "row == " << row << endl;
+
//try to accept already found cluster
AliTPCcluster *c=(AliTPCcluster*)GetCluster(idx);
Double_t chi2;
}
- seed.SetLabel(nc);
+ //seed.SetLabel(nc);
+ seed.SetNumber(nc);
return 1;
}
Int_t found=0;
Int_t nseed=fSeeds->GetEntriesFast();
+
+ cout << fInnerSec->GetNRows() << " " << fOuterSec->GetNRows() << endl;
+
for (Int_t i=0; i<nseed; i++) {
//tracking in the outer sectors
fSectors=fOuterSec; fN=fkNOS;
// 26.02.2003
//
-
if (!in->IsOpen()) {
cout << "Input File not open !\n" << endl;
return 1;
TTree *outputTree = new TTree("tracksTPC_0","Refited TPC tracks");
outputTree->Branch("tracks", "AliTPCtrack", &outTrack, 32000, 3);
+ // [SR, 01.04.2003] - Barrel tracks
+ if (IsStoringBarrel()) SetBarrelTree("refit");
+
Int_t nRefited = 0;
for(Int_t t=0; t < nTracks; t++) {
cout << t << "\r";
inputTree->GetEvent(t);
+ inTrack->ResetCovariance();
AliTPCseed *seed = new AliTPCseed(*inTrack, inTrack->GetAlpha());
- seed->ResetCovariance();
+ /*
+ //cout << inTrack->GetNumberOfClusters() << endl;
+ if (inTrack->GetNumberOfClusters() == 158) {
+ cout << inTrack->GetNumberOfClusters() << endl;
+ cout << endl;
+ for(Int_t c=0; c<inTrack->GetNumberOfClusters(); c++) {
+ Int_t idx = inTrack->GetClusterIndex(c);
+ Int_t row=(idx&0x00ff0000)>>16;
+ cout << c << " " << row << endl;
+ }
+ }
+ */
- seed->SetLabel(0);
- fSectors = fInnerSec;
+ if (IsStoringBarrel()) StoreBarrelTrack(seed, 4, 2);
+
+ seed->SetNumber(inTrack->GetNumberOfClusters()-1);
+ fSectors = fOuterSec;
Int_t res = FollowRefitInward(seed, inTrack);
UseClusters(seed);
Int_t nc = seed->GetNumberOfClusters();
- fSectors = fOuterSec;
+ if (IsStoringBarrel()) StoreBarrelTrack(seed, 3, 2);
+ if (IsStoringBarrel()) StoreBarrelTrack(seed, 2, 2);
+
+ fSectors = fInnerSec;
res = FollowRefitInward(seed, inTrack);
UseClusters(seed, nc);
+ if (IsStoringBarrel()) StoreBarrelTrack(seed, 1, 2);
+
if (res) {
seed->PropagateTo(fParam->GetInnerRadiusLow());
outTrack = (AliTPCtrack*)seed;
nRefited++;
}
+ if (IsStoringBarrel()) fBarrelTree->Fill();
delete seed;
}
cout << "Refitted " << nRefited << " tracks." << endl;
+ out->cd();
outputTree->Write();
+ // [SR, 01.04.2003]
+ if (IsStoringBarrel()) {
+ fBarrelFile->cd();
+ fBarrelTree->Write();
+ fBarrelFile->Flush();
+
+ delete fBarrelArray;
+ delete fBarrelTree;
+ }
+
if (inputTree) delete inputTree;
if (outputTree) delete outputTree;
AliTPCtrack *tpcTrack=new AliTPCtrack;
tpcTree->SetBranchAddress("tracks",&tpcTrack);
+ // [SR, 01.04.2003] - Barrel tracks
+ if (IsStoringBarrel()) SetBarrelTree("back");
+
//*** Prepare an array of tracks to be back propagated
Int_t nup=fOuterSec->GetNRows(), nlow=fInnerSec->GetNRows();
Int_t nrows=nlow+nup;
// No ITS - use TPC track only
+ tpcTrack->ResetCovariance();
AliTPCseed * seed = new AliTPCseed(*tpcTrack, tpcTrack->GetAlpha());
- seed->ResetCovariance();
+
fSeeds->AddLast(seed);
tracks.AddLast(new AliTPCtrack(*tpcTrack));
AliTPCtrack *otrack=0;
backTree.Branch("tracks","AliTPCtrack",&otrack,32000,0);
- //*** Back propagation through inner sectors
- fSectors=fInnerSec; fN=fkNIS;
+ //
+ Int_t nRefPlane;
+ Int_t found=0;
Int_t nseed=fSeeds->GetEntriesFast();
+
+ // loop changed [SR, 01.04.2003]
+
for (i=0; i<nseed; i++) {
+
+ nRefPlane = 1;
+ if (IsStoringBarrel()) fBarrelArray->Clear();
+
AliTPCseed *ps=(AliTPCseed*)fSeeds->UncheckedAt(i), &s=*ps;
const AliTPCtrack *pt=(AliTPCtrack*)tracks.UncheckedAt(i), &t=*pt;
+ ps->ResetNWrong();
+ ps->ResetNRotation();
+
+ if (IsStoringBarrel()) StoreBarrelTrack(ps, 1, 1);
+
+ // Load outer sectors
+ fSectors=fInnerSec;
+ fN=fkNIS;
+
Int_t nc=t.GetNumberOfClusters();
- s.SetLabel(nc-1); //set number of the cluster to start with
+ //s.SetLabel(nc-1); //set number of the cluster to start with
+ s.SetNumber(nc);
- if (FollowBackProlongation(s,t)) {
- UseClusters(&s);
+ if (FollowBackProlongation(s,t)) UseClusters(&s);
+ else {
+ fSeeds->RemoveAt(i);
continue;
}
- delete fSeeds->RemoveAt(i);
- }
-//*** Back propagation through outer sectors
- fSectors=fOuterSec; fN=fkNOS;
- Int_t found=0;
- for (i=0; i<nseed; i++) {
- AliTPCseed *ps=(AliTPCseed*)fSeeds->UncheckedAt(i), &s=*ps;
- if (!ps) continue;
- Int_t nc=s.GetNumberOfClusters();
- const AliTPCtrack *pt=(AliTPCtrack*)tracks.UncheckedAt(i), &t=*pt;
+ if (IsStoringBarrel()) StoreBarrelTrack(ps, 2, 1);
+ if (IsStoringBarrel()) StoreBarrelTrack(ps, 3, 1);
+
+ // Load outer sectors
+ fSectors=fOuterSec;
+ fN=fkNOS;
+
+ nc=s.GetNumberOfClusters();
Double_t alpha=s.GetAlpha() - fSectors->GetAlphaShift();
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
ps->PropagateTo(fParam->GetOuterRadiusUp());
otrack=ps;
backTree.Fill();
- found++;
-// cerr<<found<<'\r';
- continue;
+
+ if (IsStoringBarrel()) StoreBarrelTrack(ps, 4, 1);
+ cerr<<found++<<'\r';
}
}
}
+
+ if (IsStoringBarrel()) fBarrelTree->Fill();
delete fSeeds->RemoveAt(i);
}
+
+ out->cd();
backTree.Write();
+
+ // [SR, 01.04.2003]
+ if (IsStoringBarrel()) {
+ fBarrelFile->cd();
+ fBarrelTree->Write();
+ fBarrelFile->Flush();
+
+ delete fBarrelArray;
+ delete fBarrelTree;
+ }
+
savedir->cd();
cerr<<"Number of seeds: "<<nseed<<endl;
cerr<<"Number of back propagated ITS tracks: "<<bckN<<endl;
#include "AliTPCtrack.h"
#include "AliTPCreco.h"
#include "AliTPCcluster.h"
+#include "AliBarrelTrack.h"
class TFile;
class AliTPCParam;
AliTPCParam *fParam; //! TPC parameters for outer reference plane [SR, GSI, 18.02.2003]
TObjArray *fSeeds; //array of track seeds
+
+ // [SR, 01.04.2003]
+ void SetBarrelTree(const char *mode);
+ void StoreBarrelTrack(AliTPCtrack *ps, Int_t refPlane, Int_t isIn);
+
+ // [SR, 01.04.2003]
+ TFile *fBarrelFile; // file with "barrel" tracks
+ TTree *fBarrelTree; // tree with "barrel" tracks
+ TBranch *fBarrelBranch;
+ TClonesArray *fBarrelArray;
+ AliBarrelTrack *fBarrelTrack;
+
};
#endif
/*
$Log$
+Revision 1.17 2003/02/19 09:02:28 hristov
+Track time measurement (S.Radomski)
+
Revision 1.16 2003/02/10 14:06:10 cblume
Add tracking without tilted pads as option
fdEdx=0.;
fLhElectron = 0.0;
+ fNWrong = 0;
+ fNRotate = 0;
Double_t q = TMath::Abs(c->GetQ());
Double_t s = fX*fC - fE, t=fT;
fdEdx=t.fdEdx;
fLhElectron = 0.0;
+ fNWrong = t.fNWrong;
+ fNRotate = t.fNRotate;
fAlpha=t.fAlpha;
fX=t.fX;
fdEdx=0;
fLhElectron = 0.0;
+ fNWrong = 0;
+ fNRotate = 0;
fAlpha = alpha;
if (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi();
fIndex[i] = 0;
}
}
+//_____________________________________________________________________________
+
+void AliTRDtrack::GetBarrelTrack(AliBarrelTrack *track) {
+ //
+ //
+ //
+
+ if (!track) return;
+ Double_t xr, vec[5], cov[15];
+
+ track->SetLabel(GetLabel());
+ track->SetX(fX, fAlpha);
+ track->SetNClusters(GetNumberOfClusters(), GetChi2());
+ track->SetNWrongClusters(fNWrong);
+ track->SetNRotate(fNRotate);
+ track->SetTime(fIntegratedTime, fIntegratedLength);
+
+ track->SetMass(fMass);
+ track->SetdEdX(fdEdx);
+ GetExternalParameters(xr, vec);
+ track->SetStateVector(vec);
+
+ GetExternalCovariance(cov);
+ track->SetCovarianceMatrix(cov);
+}
//____________________________________________________________________________
void AliTRDtrack::GetExternalParameters(Double_t& xr, Double_t x[5]) const {
//
// Propagates a track of particle with mass=pm to a reference plane
// defined by x=xk through media of density=rho and radiationLength=x0
+ if (xk == fX) return 1;
+
if (TMath::Abs(fC*xk - fE) >= 0.99999) {
Int_t n=GetNumberOfClusters();
- if (n>4) cerr<<n<<" AliTRDtrack warning: Propagation failed !\n";
+ if (n>4) cerr << n << " AliTRDtrack: Propagation failed, \tPt = "
+ << GetPt() << "\t" << GetLabel() << "\t" << GetMass() << endl;
return 0;
}
fY += k00*dy + k01*dz;
fZ += k10*dy + k11*dz;
fE = eta;
- fT += k30*dy + k31*dz;
+ //fT += k30*dy + k31*dz;
fC = cur;
}
else {
fY += k00*dy + k01*dz;
fZ += k10*dy + k11*dz;
fE = eta;
- fT += k30*dy + k31*dz;
+ //fT += k30*dy + k31*dz;
fC = cur;
k01+=h01*k00;
Int_t AliTRDtrack::Rotate(Double_t alpha)
{
// Rotates track parameters in R*phi plane
+
+ fNRotate++;
fAlpha += alpha;
if (fAlpha<-TMath::Pi()) fAlpha += 2*TMath::Pi();
#include <AliKalmanTrack.h>
#include <TMath.h>
+#include "AliBarrelTrack.h"
+#include "AliTRDgeometry.h"
+#include "TVector2.h"
+
class AliTRDcluster;
class AliTPCtrack;
void CookdEdx(Double_t low=0.05, Double_t up=0.70);
Double_t GetAlpha() const {return fAlpha;}
+ Int_t GetSector() const {
+ //if (fabs(fAlpha) < AliTRDgeometry::GetAlpha()/2) return 0;
+ return Int_t(TVector2::Phi_0_2pi(fAlpha)/AliTRDgeometry::GetAlpha())%AliTRDgeometry::kNsect;}
+
Double_t GetC() const {return fC;}
Int_t GetClusterIndex(Int_t i) const {return fIndex[i];}
Float_t GetClusterdQdl(Int_t i) const {return fdQdl[i];}
Int_t Update(const AliTRDcluster* c, Double_t chi2, UInt_t i,
Double_t h01);
+ //
+ void GetBarrelTrack(AliBarrelTrack *track);
+ void AddNWrong() {fNWrong++;}
+
+ Int_t GetNWrong() const {return fNWrong;}
+ Int_t GetNRotate() const {return fNRotate;}
+ //
+
+
protected:
Int_t fSeedLab; // track label taken from seeding
// for track angles
Float_t fLhElectron; // Likelihood to be an electron
+ Int_t fNWrong; // number of wrong clusters
+ Int_t fNRotate;
ClassDef(AliTRDtrack,2) // TRD reconstructed tracks
/*
$Log$
+Revision 1.25 2003/03/19 17:14:11 hristov
+Load/UnloadClusters added to the base class and the derived classes changed correspondingly. Possibility to give 2 input files for ITS and TPC tracks in PropagateBack. TRD tracker uses fEventN from the base class (T.Kuhr)
+
Revision 1.24 2003/02/19 09:02:28 hristov
Track time measurement (S.Radomski)
const Double_t AliTRDtracker::fMaxChi2 = 12.;
+const Int_t AliTRDtracker::kFirstPlane = 5;
+const Int_t AliTRDtracker::kLastPlane = 17;
+
//____________________________________________________________________
-AliTRDtracker::AliTRDtracker(const TFile *geomfile)
+AliTRDtracker::AliTRDtracker(const TFile *geomfile):AliTracker()
{
//
// Main constructor
fVocal = kFALSE;
+
+ // Barrel Tracks [SR, 03.04.2003]
+
+ fBarrelFile = 0;
+ fBarrelTree = 0;
+ fBarrelArray = 0;
+ fBarrelTrack = 0;
+
+ savedir->cd();
}
//___________________________________________________________________
}
}
+//_____________________________________________________________________
+
+void AliTRDtracker::SetBarrelTree(const char *mode) {
+ //
+ //
+ //
+
+ if (!IsStoringBarrel()) return;
+
+ TDirectory *sav = gDirectory;
+ if (!fBarrelFile) fBarrelFile = new TFile("AliBarrelTracks.root", "UPDATE");
+
+ char buff[40];
+ sprintf(buff, "BarrelTRD_%d_%s", GetEventNumber(), mode);
+
+ fBarrelFile->cd();
+ fBarrelTree = new TTree(buff, "Barrel TPC tracks");
+
+ Int_t nRefs = kLastPlane - kFirstPlane + 1;
+
+ if (!fBarrelArray) fBarrelArray = new TClonesArray("AliBarrelTrack", nRefs);
+ for(Int_t i=0; i<nRefs; i++) new((*fBarrelArray)[i]) AliBarrelTrack();
+
+ fBarrelTree->Branch("tracks", &fBarrelArray);
+ sav->cd();
+}
+
+//_____________________________________________________________________
+
+void AliTRDtracker::StoreBarrelTrack(AliTRDtrack *ps, Int_t refPlane, Int_t isIn) {
+ //
+ //
+ //
+
+ if (!IsStoringBarrel()) return;
+
+ static Int_t nClusters;
+ static Int_t nWrong;
+ static Double_t chi2;
+ static Int_t index;
+ static Bool_t wasLast = kTRUE;
+
+ Int_t newClusters, newWrong;
+ Double_t newChi2;
+
+ if (wasLast) {
+
+ fBarrelArray->Clear();
+ nClusters = nWrong = 0;
+ chi2 = 0.0;
+ index = 0;
+ wasLast = kFALSE;
+ }
+
+ fBarrelTrack = (AliBarrelTrack*)(*fBarrelArray)[index++];
+ ps->GetBarrelTrack(fBarrelTrack);
+
+ newClusters = ps->GetNumberOfClusters() - nClusters;
+ newWrong = ps->GetNWrong() - nWrong;
+ newChi2 = ps->GetChi2() - chi2;
+
+ nClusters = ps->GetNumberOfClusters();
+ nWrong = ps->GetNWrong();
+ chi2 = ps->GetChi2();
+
+ if (refPlane != kLastPlane) {
+ fBarrelTrack->SetNClusters(newClusters, newChi2);
+ fBarrelTrack->SetNWrongClusters(newWrong);
+ } else {
+ wasLast = kTRUE;
+ }
+
+ fBarrelTrack->SetRefPlane(refPlane, isIn);
+}
+
+//_____________________________________________________________________
+
+Bool_t AliTRDtracker::AdjustSector(AliTRDtrack *track) {
+ //
+ // Rotates the track when necessary
+ //
+
+ Double_t alpha = AliTRDgeometry::GetAlpha();
+ Double_t y = track->GetY();
+ Double_t ymax = track->GetX()*TMath::Tan(0.5*alpha);
+
+ Int_t ns = AliTRDgeometry::kNsect;
+ //Int_t s=Int_t(track->GetAlpha()/alpha)%ns;
+
+ if (y > ymax) {
+ //s = (s+1) % ns;
+ if (!track->Rotate(alpha)) return kFALSE;
+ } else if (y <-ymax) {
+ //s = (s-1+ns) % ns;
+ if (!track->Rotate(-alpha)) return kFALSE;
+ }
+
+ return kTRUE;
+}
+
//_____________________________________________________________________
inline Double_t f1trd(Double_t x1,Double_t y1,
Double_t x2,Double_t y2,
AliTRDtrack *otrack_trd=0;
trdTree.Branch("tracks","AliTRDtrack",&otrack_trd,32000,0);
- Int_t found=0;
+ if (IsStoringBarrel()) SetBarrelTree("back");
+ out->cd();
+ Int_t found=0;
Int_t nseed=fSeeds->GetEntriesFast();
// Float_t foundMin = fMinClustersInTrack * fTimeBinsPerPlane * fGeom->Nplan();
- Float_t foundMin = 0;
+ Float_t foundMin = 40;
Int_t outermost_tb = fTrSec[0]->GetOuterTimeBin();
AliTRDtrack *ps=(AliTRDtrack*)fSeeds->UncheckedAt(i), &s=*ps;
Int_t expectedClr = FollowBackProlongation(s);
+
+ if (IsStoringBarrel()) {
+ StoreBarrelTrack(ps, kLastPlane, kTrackBack);
+ fBarrelTree->Fill();
+ }
+
Int_t foundClr = s.GetNumberOfClusters();
Int_t last_tb = fTrSec[0]->GetLayerNumber(s.GetX());
}
}
+
+ out->cd();
tofTree1.Write();
tofTree2.Write();
phosTree.Write();
richTree.Write();
trdTree.Write();
+ if (IsStoringBarrel()) { // [SR, 03.04.2003]
+ fBarrelFile->cd();
+ fBarrelTree->Write();
+ fBarrelFile->Flush();
+ }
+
savedir->cd();
cerr<<"Number of seeds: "<<nseed<<endl;
cerr<<"Number of back propagated TRD tracks: "<<found<<endl;
Int_t try_again=fMaxGap;
Double_t alpha=t.GetAlpha();
-
- if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
- if (alpha < 0. ) alpha += 2.*TMath::Pi();
+ TVector2::Phi_0_2pi(alpha);
Int_t s=Int_t(alpha/AliTRDgeometry::GetAlpha())%AliTRDgeometry::kNsect;
-
Double_t rad_length, rho, x, dx, y, ymax, z;
Int_t expectedNumberOfClusters = 0;
Float_t wSigmaC2, wSigmaTgl2, wSigmaY2, wSigmaZ2;
Int_t trackIndex = t.GetLabel();
-
- Int_t ns=Int_t(2*TMath::Pi()/AliTRDgeometry::GetAlpha()+0.5);
-
Int_t try_again=fMaxGap;
Double_t alpha=t.GetAlpha();
+ TVector2::Phi_0_2pi(alpha);
- if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
- if (alpha < 0. ) alpha += 2.*TMath::Pi();
-
- Int_t s=Int_t(alpha/AliTRDgeometry::GetAlpha())%AliTRDgeometry::kNsect;
+ Int_t s;
Int_t outerTB = fTrSec[0]->GetOuterTimeBin();
-
- Double_t rad_length, rho, x, dx, y, ymax, z;
-
+ Double_t rad_length, rho, x, dx, y, ymax = 0, z;
Bool_t lookForCluster;
Int_t expectedNumberOfClusters = 0;
alpha=AliTRDgeometry::GetAlpha(); // note: change in meaning
+ Int_t nRefPlane = kFirstPlane;
+ Bool_t isNewLayer = kFALSE;
- for (Int_t nr=fTrSec[0]->GetLayerNumber(t.GetX()); nr<outerTB; nr++) {
+ Double_t chi2;
+ Double_t minDY;
- y = t.GetY(); z = t.GetZ();
+ for (Int_t nr=fTrSec[0]->GetLayerNumber(t.GetX()); nr<outerTB+1; nr++) {
+
+ y = t.GetY();
+ z = t.GetZ();
// first propagate to the outer surface of the current time bin
+ s = t.GetSector();
fTrSec[s]->GetLayer(nr)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
- x = fTrSec[s]->GetLayer(nr)->GetX()+dx/2; y = t.GetY(); z = t.GetZ();
+ x = fTrSec[s]->GetLayer(nr)->GetX()+dx/2;
+ y = t.GetY();
+ z = t.GetZ();
if(!t.PropagateTo(x,rad_length,rho)) break;
+ if (!AdjustSector(&t)) break;
+ s = t.GetSector();
+ if (!t.PropagateTo(x,rad_length,rho)) break;
y = t.GetY();
- ymax = x*TMath::Tan(0.5*alpha);
+ z = t.GetZ();
- if (y > ymax) {
- s = (s+1) % ns;
- if (!t.Rotate(alpha)) break;
- if(!t.PropagateTo(x,rad_length,rho)) break;
- } else if (y <-ymax) {
- s = (s-1+ns) % ns;
- if (!t.Rotate(-alpha)) break;
- if(!t.PropagateTo(x,rad_length,rho)) break;
- }
- y = t.GetY(); z = t.GetZ();
+ // Barrel Tracks [SR, 04.04.2003]
- // now propagate to the middle plane of the next time bin
- fTrSec[s]->GetLayer(nr+1)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
+ s = t.GetSector();
+ if (fTrSec[s]->GetLayer(nr)->IsSensitive() !=
+ fTrSec[s]->GetLayer(nr+1)->IsSensitive() ) {
- x = fTrSec[s]->GetLayer(nr+1)->GetX(); y = t.GetY(); z = t.GetZ();
+ if (IsStoringBarrel()) StoreBarrelTrack(&t, nRefPlane++, kTrackBack);
+ }
- if(!t.PropagateTo(x,rad_length,rho)) break;
+ if (fTrSec[s]->GetLayer(nr-1)->IsSensitive() &&
+ ! fTrSec[s]->GetLayer(nr)->IsSensitive()) {
+ isNewLayer = kTRUE;
+ } else {isNewLayer = kFALSE;}
y = t.GetY();
+ z = t.GetZ();
- ymax = x*TMath::Tan(0.5*alpha);
-
- if(fVocal) printf("nr+1=%d, x %f, z %f, y %f, ymax %f\n",nr+1,x,z,y,ymax);
+ // now propagate to the middle plane of the next time bin
+ fTrSec[s]->GetLayer(nr+1)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
- if (y > ymax) {
- s = (s+1) % ns;
- if (!t.Rotate(alpha)) break;
+ x = fTrSec[s]->GetLayer(nr+1)->GetX();
if(!t.PropagateTo(x,rad_length,rho)) break;
- } else if (y <-ymax) {
- s = (s-1+ns) % ns;
- if (!t.Rotate(-alpha)) break;
+ if (!AdjustSector(&t)) break;
+ s = t.GetSector();
if(!t.PropagateTo(x,rad_length,rho)) break;
- }
+ y = t.GetY();
+ z = t.GetZ();
+
+ if(fVocal) printf("nr+1=%d, x %f, z %f, y %f, ymax %f\n",nr+1,x,z,y,ymax);
// printf("label %d, pl %d, lookForCluster %d \n",
// trackIndex, nr+1, lookForCluster);
Double_t max_chi2=fMaxChi2;
+ if (isNewLayer) {
+ road = 3 * road;
+ //sz2 = 3 * sz2;
+ max_chi2 = 10 * fMaxChi2;
+ }
+
+ if (nRefPlane == kFirstPlane) max_chi2 = 20 * fMaxChi2;
+ if (nRefPlane == kFirstPlane+2) max_chi2 = 15 * fMaxChi2;
+ if (t.GetNRotate() > 0) max_chi2 = 3 * max_chi2;
+
+
wYclosest = 12345678;
wYcorrect = 12345678;
wZclosest = 12345678;
// Find the closest correct cluster for debugging purposes
if (time_bin) {
- Float_t minDY = 1000000;
+ minDY = 1000000;
for (Int_t i=0; i<time_bin; i++) {
AliTRDcluster* c=(AliTRDcluster*)(time_bin[i]);
if((c->GetLabel(0) != trackIndex) &&
(c->GetLabel(1) != trackIndex) &&
(c->GetLabel(2) != trackIndex)) continue;
if(TMath::Abs(c->GetY() - y) > minDY) continue;
- minDY = TMath::Abs(c->GetY() - y);
+ //minDY = TMath::Abs(c->GetY() - y);
+ minDY = c->GetY() - y;
wYcorrect = c->GetY();
wZcorrect = c->GetZ();
for (Int_t i=time_bin.Find(y-road); i<time_bin; i++) {
AliTRDcluster* c=(AliTRDcluster*)(time_bin[i]);
if (c->GetY() > y+road) break;
- // if (c->IsUsed() > 0) continue;
+ if (c->IsUsed() > 0) continue;
if((c->GetZ()-z)*(c->GetZ()-z) > 3 * sz2) continue;
Double_t h01 = GetTiltFactor(c);
- Double_t chi2=t.GetPredictedChi2(c,h01);
+ chi2=t.GetPredictedChi2(c,h01);
if (chi2 > max_chi2) continue;
max_chi2=chi2;
cl=c;
index=time_bin.GetIndex(i);
+
+ //check is correct
+ if((c->GetLabel(0) != trackIndex) &&
+ (c->GetLabel(1) != trackIndex) &&
+ (c->GetLabel(2) != trackIndex)) t.AddNWrong();
}
if(!cl) {
AliTRDcluster* c=(AliTRDcluster*)(time_bin[i]);
if (c->GetY() > y+road) break;
- // if (c->IsUsed() > 0) continue;
+ if (c->IsUsed() > 0) continue;
if((c->GetZ()-z)*(c->GetZ()-z) > 2.25 * 12 * sz2) continue;
Double_t h01 = GetTiltFactor(c);
- Double_t chi2=t.GetPredictedChi2(c,h01);
+ chi2=t.GetPredictedChi2(c,h01);
if (chi2 > max_chi2) continue;
max_chi2=chi2;
else {
if (try_again==0) break;
try_again--;
+
+ //if (minDY < 1000000 && isNewLayer)
+ //cout << "\t" << nRefPlane << "\t" << "\t" << t.GetNRotate() << "\t" <<
+ // road << "\t" << minDY << "\t" << chi2 << "\t" << wChi2 << "\t" << max_chi2 << endl;
+
}
+ isNewLayer = kFALSE;
+
/*
if((((Int_t) wTB)%15 == 0) || (((Int_t) wTB)%15 == 14)) {
}
}
return expectedNumberOfClusters;
+
+
}
//___________________________________________________________________
Int_t ns=Int_t(2*TMath::Pi()/AliTRDgeometry::GetAlpha()+0.5);
Double_t alpha=t.GetAlpha();
-
- if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
- if (alpha < 0. ) alpha += 2.*TMath::Pi();
+ TVector2::Phi_0_2pi(alpha);
Int_t s=Int_t(alpha/AliTRDgeometry::GetAlpha())%AliTRDgeometry::kNsect;
x = t.GetX();
alpha=AliTRDgeometry::GetAlpha(); // note: change in meaning
-
Int_t plTPC = fTrSec[0]->GetLayerNumber(246.055);
for (Int_t nr=fTrSec[0]->GetLayerNumber(x); nr>plTPC; nr--) {
- y = t.GetY(); z = t.GetZ();
+ y = t.GetY();
+ z = t.GetZ();
// first propagate to the outer surface of the current time bin
fTrSec[s]->GetLayer(nr)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
- x = fTrSec[s]->GetLayer(nr)->GetX()-dx/2; y = t.GetY(); z = t.GetZ();
+ x = fTrSec[s]->GetLayer(nr)->GetX()-dx/2;
+
if(!t.PropagateTo(x,rad_length,rho)) return 0;
- y = t.GetY();
- ymax = x*TMath::Tan(0.5*alpha);
- if (y > ymax) {
- s = (s+1) % ns;
- if (!t.Rotate(alpha)) return 0;
- } else if (y <-ymax) {
- s = (s-1+ns) % ns;
- if (!t.Rotate(-alpha)) return 0;
- }
+ AdjustSector(&t);
if(!t.PropagateTo(x,rad_length,rho)) return 0;
- y = t.GetY(); z = t.GetZ();
+ y = t.GetY();
+ z = t.GetZ();
// now propagate to the middle plane of the next time bin
fTrSec[s]->GetLayer(nr-1)->GetPropagationParameters(y,z,dx,rho,rad_length,lookForCluster);
- x = fTrSec[s]->GetLayer(nr-1)->GetX(); y = t.GetY(); z = t.GetZ();
+ x = fTrSec[s]->GetLayer(nr-1)->GetX();
+
if(!t.PropagateTo(x,rad_length,rho)) return 0;
- y = t.GetY();
- ymax = x*TMath::Tan(0.5*alpha);
- if (y > ymax) {
- s = (s+1) % ns;
- if (!t.Rotate(alpha)) return 0;
- } else if (y <-ymax) {
- s = (s-1+ns) % ns;
- if (!t.Rotate(-alpha)) return 0;
- }
+ AdjustSector(&t);
if(!t.PropagateTo(x,rad_length,rho)) return 0;
}
return 1;
}
-
//_____________________________________________________________________________
void AliTRDtracker::LoadEvent()
{
#include "AliTracker.h"
#include "TObjArray.h"
+#include "AliBarrelTrack.h"
class TFile;
class TParticle;
Int_t Clusters2Tracks(const TFile *in, TFile *out);
Int_t PropagateBack(const TFile *in, TFile *out);
+ //Int_t Refit(const TFile *in, TFile *out);
+
Int_t LoadClusters() {LoadEvent(); return 0;};
void UnloadClusters() {UnloadEvent();};
AliCluster *GetCluster(Int_t index) const { return (AliCluster*) fClusters->UncheckedAt(index); };
Double_t rho = 1.29e-3, Double_t x0 = 36.66,
Double_t Yc = 0, Double_t Zc = 0);
+ Bool_t IsSensitive() {return (fTimeBinIndex>=0)? kTRUE: kFALSE;}
+
void Clear() {for(Int_t i=0; i<fN; i++) fClusters[i] = NULL; fN = 0;}
private:
Int_t FollowProlongation(AliTRDtrack& t, Int_t rf);
Int_t FollowBackProlongation(AliTRDtrack& t);
+ //Int_t FolowRefitInward(AliTRDtrack *seed, AliTPCtrack *track);
Int_t PropagateToTPC(AliTRDtrack& t);
Int_t PropagateToOuterPlane(AliTRDtrack& t, Double_t x);
Bool_t fNoTilt;
+
+ Bool_t AdjustSector(AliTRDtrack *track);
+
+
+ // Barrel tracks [SR, 03.04.2003]
+
+ static const Int_t kFirstPlane; // Id of the first (innermost) reference plane
+ static const Int_t kLastPlane; // Id of the last (outermost) reference plane
+
+ void SetBarrelTree(const char *mode);
+ void StoreBarrelTrack(AliTRDtrack *ps, Int_t refPlane, Int_t isIn);
+
+ TFile *fBarrelFile;
+ TTree *fBarrelTree;
+ TClonesArray *fBarrelArray;
+ AliBarrelTrack *fBarrelTrack;
+
+
ClassDef(AliTRDtracker,1) // manager base class
};