From 9c9d24878414db1f6729c0cd67a98d61a65bc92d Mon Sep 17 00:00:00 2001 From: hristov Date: Thu, 10 Apr 2003 10:36:54 +0000 Subject: [PATCH] Code for unified TPC/TRD tracking (S.Radomski) --- STEER/AliBarrelTrack.cxx | 123 ++++++++++++++++ STEER/AliBarrelTrack.h | 113 +++++++++++++++ STEER/AliKalmanTrack.h | 4 +- STEER/AliTrackReference.h | 9 ++ STEER/AliTracker.h | 14 +- STEER/STEERLinkDef.h | 1 + STEER/libSTEER.pkg | 2 +- TPC/AliTPCtrack.cxx | 46 ++++++ TPC/AliTPCtrack.h | 21 +++ TPC/AliTPCtracker.cxx | 259 ++++++++++++++++++++++++++++----- TPC/AliTPCtracker.h | 13 ++ TRD/AliTRDtrack.cxx | 45 +++++- TRD/AliTRDtrack.h | 19 +++ TRD/AliTRDtracker.cxx | 295 ++++++++++++++++++++++++++++---------- TRD/AliTRDtracker.h | 24 ++++ 15 files changed, 868 insertions(+), 120 deletions(-) create mode 100644 STEER/AliBarrelTrack.cxx create mode 100644 STEER/AliBarrelTrack.h diff --git a/STEER/AliBarrelTrack.cxx b/STEER/AliBarrelTrack.cxx new file mode 100644 index 00000000000..f83c2e5c049 --- /dev/null +++ b/STEER/AliBarrelTrack.cxx @@ -0,0 +1,123 @@ + +//////////////////////////////////////////////////////////////////////////////// +// +// 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]; +} + +//////////////////////////////////////////////////////////////////////////////// diff --git a/STEER/AliBarrelTrack.h b/STEER/AliBarrelTrack.h new file mode 100644 index 00000000000..67257d1ed3e --- /dev/null +++ b/STEER/AliBarrelTrack.h @@ -0,0 +1,113 @@ + +#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 diff --git a/STEER/AliKalmanTrack.h b/STEER/AliKalmanTrack.h index 87a33ade49d..7cbacf224b5 100644 --- a/STEER/AliKalmanTrack.h +++ b/STEER/AliKalmanTrack.h @@ -100,11 +100,11 @@ public: 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 @@ -117,6 +117,8 @@ private: Bool_t fStartTimeIntegral; // indicator wether integrate time Float_t fIntegratedTime[5]; // intgrated time Float_t fIntegratedLength; // integrated length + + public: ClassDef(AliKalmanTrack,2) // Reconstructed track }; diff --git a/STEER/AliTrackReference.h b/STEER/AliTrackReference.h index 04ebf7b41ed..fc8117b14ab 100644 --- a/STEER/AliTrackReference.h +++ b/STEER/AliTrackReference.h @@ -38,6 +38,15 @@ public: 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 diff --git a/STEER/AliTracker.h b/STEER/AliTracker.h index b522c3d4a7e..d3edf15508c 100644 --- a/STEER/AliTracker.h +++ b/STEER/AliTracker.h @@ -17,8 +17,13 @@ class AliCluster; 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; @@ -28,6 +33,8 @@ public: } void SetEventNumber(Int_t ev) { fEventN=ev; } + + //protected: virtual Int_t LoadClusters()=0; virtual void UnloadClusters()=0; @@ -46,9 +53,14 @@ public: 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 diff --git a/STEER/STEERLinkDef.h b/STEER/STEERLinkDef.h index 8f5e33b6959..62e68e7ae1f 100644 --- a/STEER/STEERLinkDef.h +++ b/STEER/STEERLinkDef.h @@ -63,6 +63,7 @@ #pragma link C++ class AliTrackMapper+; #pragma link C++ class AliCollisionGeometry+; #pragma link C++ class AliMemoryWatcher+; +#pragma link C++ class AliBarrelTrack+; #endif diff --git a/STEER/libSTEER.pkg b/STEER/libSTEER.pkg index dc2db5b5794..99894f39eef 100644 --- a/STEER/libSTEER.pkg +++ b/STEER/libSTEER.pkg @@ -15,7 +15,7 @@ AliRunDigitizer.cxx AliDigitizer.cxx AliStream.cxx \ 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) diff --git a/TPC/AliTPCtrack.cxx b/TPC/AliTPCtrack.cxx index 8801d9b3c10..dc292ebb96c 100644 --- a/TPC/AliTPCtrack.cxx +++ b/TPC/AliTPCtrack.cxx @@ -15,6 +15,9 @@ /* $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 @@ -55,6 +58,7 @@ Logs added #include "AliTPCtrack.h" #include "AliCluster.h" +#include "AliBarrelTrack.h" ClassImp(AliTPCtrack) @@ -63,6 +67,7 @@ AliTPCtrack::AliTPCtrack(): AliKalmanTrack() { fX = fP0 = fP1 = fP2 = fP3 = fP3 = fP4 = 0.0; fAlpha = fdEdx = 0.0; + fNWrong = fNRotation = fNumber = 0; // [SR, 01.04.2003] } //_________________________________________________________________________ @@ -149,7 +154,37 @@ AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) : AliKalmanTrack(t) { Int_t n=GetNumberOfClusters(); for (Int_t i=0; iSetLabel(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 { //----------------------------------------------------------------- @@ -315,6 +350,14 @@ Int_t AliTPCtrack::Update(const AliCluster *c, Double_t chisq, UInt_t index) { //----------------------------------------------------------------- // 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; @@ -373,6 +416,9 @@ Int_t AliTPCtrack::Rotate(Double_t alpha) //----------------------------------------------------------------- // 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(); diff --git a/TPC/AliTPCtrack.h b/TPC/AliTPCtrack.h index 3d0cfbc5e8c..203dd3766a4 100644 --- a/TPC/AliTPCtrack.h +++ b/TPC/AliTPCtrack.h @@ -32,6 +32,8 @@ #include "AliTPCreco.h" +class AliBarrelTrack; + //_____________________________________________________________________________ class AliTPCtrack : public AliKalmanTrack { public: @@ -74,6 +76,20 @@ 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 !!! ************** @@ -114,6 +130,11 @@ protected: 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 }; diff --git a/TPC/AliTPCtracker.cxx b/TPC/AliTPCtracker.cxx index 7cda215b963..2bbf4f2afb3 100644 --- a/TPC/AliTPCtracker.cxx +++ b/TPC/AliTPCtracker.cxx @@ -15,6 +15,9 @@ /* $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 @@ -125,6 +128,14 @@ AliTracker(), fkNIS(par->GetNInnerSector()/2), fkNOS(par->GetNOuterSector()/2) fParam = (AliTPCParam*) par; fSeeds=0; + + // [SR 17.03.2003] + + fBarrelFile = 0; + fBarrelTree = 0; + fBarrelArray = 0; + fBarrelTrack = 0; + } //_____________________________________________________________________________ @@ -138,6 +149,96 @@ AliTPCtracker::~AliTPCtracker() { 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); } //_____________________________________________________________________________ @@ -358,6 +459,10 @@ Int_t AliTPCtracker::FollowProlongation(AliTPCseed& t, Int_t rf) { return 0; } + //if (fSectors == fInnerSec && (nr == 63 || nr == 0)) { + // cout << nr << "\t" << krow << endl; + //} + if (krow) { for (Int_t i=krow.Find(y-road); iGetAlpha())%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; @@ -419,7 +524,10 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) { else { if (sec < fkNIS) row=-1; } Int_t nr=fSectors->GetNRows(); - for (Int_t i=0; 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; @@ -443,10 +551,9 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) { 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); @@ -455,7 +562,9 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) { 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; @@ -467,8 +576,6 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) { } 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()); @@ -476,7 +583,7 @@ Int_t AliTPCtracker::FollowRefitInward(AliTPCseed *seed, AliTPCtrack *track) { } } - seed->SetLabel(nc); + seed->SetNumber(nc); return 1; } @@ -492,7 +599,9 @@ Int_t AliTPCtracker::FollowBackProlongation 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; @@ -504,6 +613,8 @@ Int_t AliTPCtracker::FollowBackProlongation for (Int_t i=0; iGetX(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(); @@ -528,9 +639,12 @@ Int_t AliTPCtracker::FollowBackProlongation 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; @@ -574,7 +688,8 @@ Int_t AliTPCtracker::FollowBackProlongation } - seed.SetLabel(nc); + //seed.SetLabel(nc); + seed.SetNumber(nc); return 1; } @@ -763,6 +878,9 @@ Int_t AliTPCtracker::Clusters2Tracks(const TFile *inp, TFile *out) { Int_t found=0; Int_t nseed=fSeeds->GetEntriesFast(); + + cout << fInnerSec->GetNRows() << " " << fOuterSec->GetNRows() << endl; + for (Int_t i=0; iIsOpen()) { cout << "Input File not open !\n" << endl; return 1; @@ -854,6 +971,9 @@ Int_t AliTPCtracker::RefitInward(TFile *in, TFile *out) { 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++) { @@ -861,20 +981,39 @@ Int_t AliTPCtracker::RefitInward(TFile *in, TFile *out) { 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; cGetNumberOfClusters(); 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; @@ -883,13 +1022,25 @@ Int_t AliTPCtracker::RefitInward(TFile *in, TFile *out) { 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; @@ -955,6 +1106,9 @@ Int_t AliTPCtracker::PropagateBack(const TFile *inp, const TFile *inp2, TFile *o 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; @@ -996,8 +1150,9 @@ Int_t AliTPCtracker::PropagateBack(const TFile *inp, const TFile *inp2, TFile *o // 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)); @@ -1053,31 +1208,48 @@ Int_t AliTPCtracker::PropagateBack(const TFile *inp, const TFile *inp2, TFile *o 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; iClear(); + 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; iUncheckedAt(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(); @@ -1100,16 +1272,31 @@ Int_t AliTPCtracker::PropagateBack(const TFile *inp, const TFile *inp2, TFile *o ps->PropagateTo(fParam->GetOuterRadiusUp()); otrack=ps; backTree.Fill(); - found++; -// cerr<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: "<GetQ()); Double_t s = fX*fC - fE, t=fT; @@ -129,6 +134,8 @@ AliTRDtrack::AliTRDtrack(const AliTRDtrack& t) : AliKalmanTrack(t) { fdEdx=t.fdEdx; fLhElectron = 0.0; + fNWrong = t.fNWrong; + fNRotate = t.fNRotate; fAlpha=t.fAlpha; fX=t.fX; @@ -170,6 +177,8 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha) fdEdx=0; fLhElectron = 0.0; + fNWrong = 0; + fNRotate = 0; fAlpha = alpha; if (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi(); @@ -208,7 +217,32 @@ AliTRDtrack::AliTRDtrack(const AliKalmanTrack& t, Double_t alpha) 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 { // @@ -311,9 +345,12 @@ Int_t AliTRDtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho) // 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<4) cerr << n << " AliTRDtrack: Propagation failed, \tPt = " + << GetPt() << "\t" << GetLabel() << "\t" << GetMass() << endl; return 0; } @@ -432,7 +469,7 @@ Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, UInt_t index, 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 { @@ -462,7 +499,7 @@ Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, UInt_t index, 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; @@ -503,6 +540,8 @@ Int_t AliTRDtrack::Update(const AliTRDcluster *c, Double_t chisq, UInt_t index, 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(); diff --git a/TRD/AliTRDtrack.h b/TRD/AliTRDtrack.h index 31eeafe3cb3..6a92c398122 100644 --- a/TRD/AliTRDtrack.h +++ b/TRD/AliTRDtrack.h @@ -7,6 +7,10 @@ #include #include +#include "AliBarrelTrack.h" +#include "AliTRDgeometry.h" +#include "TVector2.h" + class AliTRDcluster; class AliTPCtrack; @@ -28,6 +32,10 @@ public: 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];} @@ -78,6 +86,15 @@ public: 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 @@ -104,6 +121,8 @@ protected: // 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 diff --git a/TRD/AliTRDtracker.cxx b/TRD/AliTRDtracker.cxx index 0287f0678d5..4b666449257 100644 --- a/TRD/AliTRDtracker.cxx +++ b/TRD/AliTRDtracker.cxx @@ -15,6 +15,9 @@ /* $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) @@ -126,9 +129,12 @@ ClassImp(AliTRDtracker) 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 @@ -213,6 +219,15 @@ AliTRDtracker::AliTRDtracker(const TFile *geomfile) fVocal = kFALSE; + + // Barrel Tracks [SR, 03.04.2003] + + fBarrelFile = 0; + fBarrelTree = 0; + fBarrelArray = 0; + fBarrelTrack = 0; + + savedir->cd(); } //___________________________________________________________________ @@ -229,6 +244,106 @@ AliTRDtracker::~AliTRDtracker() } } +//_____________________________________________________________________ + +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; iBranch("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, @@ -530,12 +645,14 @@ Int_t AliTRDtracker::PropagateBack(const TFile *inp, TFile *out) { 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(); @@ -543,6 +660,12 @@ Int_t AliTRDtracker::PropagateBack(const TFile *inp, TFile *out) { 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()); @@ -607,12 +730,20 @@ Int_t AliTRDtracker::PropagateBack(const TFile *inp, TFile *out) { } } + + 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: "< 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; @@ -869,22 +997,15 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t) 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; @@ -892,55 +1013,63 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t) alpha=AliTRDgeometry::GetAlpha(); // note: change in meaning + Int_t nRefPlane = kFirstPlane; + Bool_t isNewLayer = kFALSE; - for (Int_t nr=fTrSec[0]->GetLayerNumber(t.GetX()); nrGetLayerNumber(t.GetX()); nrGetLayer(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); @@ -983,6 +1112,17 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t) 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; @@ -991,14 +1131,15 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t) // Find the closest correct cluster for debugging purposes if (time_bin) { - Float_t minDY = 1000000; + minDY = 1000000; for (Int_t i=0; iGetLabel(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(); @@ -1014,16 +1155,21 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t) for (Int_t i=time_bin.Find(y-road); iGetY() > 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) { @@ -1032,11 +1178,11 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t) 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; @@ -1059,8 +1205,15 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t) 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)) { @@ -1090,6 +1243,8 @@ Int_t AliTRDtracker::FollowBackProlongation(AliTRDtrack& t) } } return expectedNumberOfClusters; + + } //___________________________________________________________________ @@ -1169,9 +1324,7 @@ Int_t AliTRDtracker::PropagateToTPC(AliTRDtrack& t) 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; @@ -1181,49 +1334,35 @@ Int_t AliTRDtracker::PropagateToTPC(AliTRDtrack& t) 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() { diff --git a/TRD/AliTRDtracker.h b/TRD/AliTRDtracker.h index 3b49c50c750..0bcc07d929b 100644 --- a/TRD/AliTRDtracker.h +++ b/TRD/AliTRDtracker.h @@ -6,6 +6,7 @@ #include "AliTracker.h" #include "TObjArray.h" +#include "AliBarrelTrack.h" class TFile; class TParticle; @@ -33,6 +34,8 @@ class AliTRDtracker : public AliTracker { 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); }; @@ -111,6 +114,8 @@ class AliTRDtracker : public AliTracker { 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