* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
+/* $Id$ */
//-------------------------------------------------------------------------
// Implementation of the ITS tracker class
// It reads AliITSRecPoint clusters and creates AliITStrackV2 tracks
#include "AliITSgeomTGeo.h"
#include "AliAlignObj.h"
#include "AliITSRecPoint.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
+#include "AliESDtrack.h"
#include "AliITSRecPoint.h"
#include "AliITSReconstructor.h"
#include "AliITStrackerV2.h"
ClassImp(AliITStrackerV2)
-AliITStrackerV2::AliITSlayer AliITStrackerV2::fgLayers[kMaxLayer]; //ITS layers
+AliITStrackerV2::AliITSlayer AliITStrackerV2::fgLayers[AliITSgeomTGeo::kNLayers]; //ITS layers
AliITStrackerV2::AliITStrackerV2():
AliTracker(),
- fI(kMaxLayer),
+ fI(AliITSgeomTGeo::GetNLayers()),
fBestTrack(),
fTrackToFollow(),
fPass(0),
- fLastLayerToTrackTo(kLastLayerToTrackTo)
+ fLastLayerToTrackTo(AliITSRecoParam::GetLastLayerToTrackTo())
{
//--------------------------------------------------------------------
//This is the AliITStrackerV2 default constructor
//--------------------------------------------------------------------
- for (Int_t i=1; i<kMaxLayer+1; i++) new(fgLayers+i-1) AliITSlayer();
+ for (Int_t i=1; i<AliITSgeomTGeo::GetNLayers()+1; i++) new(fgLayers+i-1) AliITSlayer();
fConstraint[0]=1; fConstraint[1]=0;
AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()};
SetVertex(xyz,ers);
- for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=kLayersNotToSkip[i];
+ for (Int_t i=0; i<AliITSgeomTGeo::GetNLayers(); i++) fLayersNotToSkip[i]=AliITSRecoParam::GetLayersNotToSkip(i);
}
//This is the AliITStrackerV2 copy constructor
//--------------------------------------------------------------------
- //for (Int_t i=1; i<kMaxLayer+1; i++) new(fgLayers+i-1) AliITSlayer();
+ //for (Int_t i=1; i<AliITSgeomTGeo::GetNLayers()+1; i++) new(fgLayers+i-1) AliITSlayer();
fConstraint[0]=t.fConstraint[0]; fConstraint[1]=t.fConstraint[1];
ers[0]=t.GetSigmaX(); ers[1]=t.GetSigmaY(); ers[2]=t.GetSigmaZ();
SetVertex(xyz,ers);
- for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=t.fLayersNotToSkip[i];
+ for (Int_t i=0; i<AliITSgeomTGeo::GetNLayers(); i++) fLayersNotToSkip[i]=t.fLayersNotToSkip[i];
}
AliITStrackerV2::AliITStrackerV2(const Char_t *geom) :
AliTracker(),
- fI(kMaxLayer),
+ fI(AliITSgeomTGeo::GetNLayers()),
fBestTrack(),
fTrackToFollow(),
fPass(0),
- fLastLayerToTrackTo(kLastLayerToTrackTo)
+ fLastLayerToTrackTo(AliITSRecoParam::GetLastLayerToTrackTo())
{
//--------------------------------------------------------------------
//This is the AliITStrackerV2 constructor
AliWarning("\"geom\" is actually a dummy argument !");
}
- for (Int_t i=1; i<kMaxLayer+1; i++) {
+ for (Int_t i=1; i<AliITSgeomTGeo::GetNLayers()+1; i++) {
Int_t nlad=AliITSgeomTGeo::GetNLadders(i);
Int_t ndet=AliITSgeomTGeo::GetNDetectors(i);
TGeoHMatrix m; AliITSgeomTGeo::GetOrigMatrix(i,j,k,m);
const TGeoHMatrix *tm=AliITSgeomTGeo::GetTracking2LocalMatrix(i,j,k);
m.Multiply(tm);
- Double_t txyz[3]={0.}, xyz[3]={0.};
+ Double_t txyz[3]={0.};
+ xyz[0]=0.; xyz[1]=0.; xyz[2]=0.;
m.LocalToMaster(txyz,xyz);
- Double_t r=TMath::Sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
+ r=TMath::Sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]);
Double_t phi=TMath::ATan2(xyz[1],xyz[0]);
if (phi<0) phi+=TMath::TwoPi();
AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()};
SetVertex(xyz,ers);
- for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=kLayersNotToSkip[i];
+ for (Int_t i=0; i<AliITSgeomTGeo::GetNLayers(); i++) fLayersNotToSkip[i]=AliITSRecoParam::GetLayersNotToSkip(i);
}
//--------------------------------------------------------------------
//This function set masks of the layers which must be not skipped
//--------------------------------------------------------------------
- for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=l[i];
+ for (Int_t i=0; i<AliITSgeomTGeo::GetNLayers(); i++) fLayersNotToSkip[i]=l[i];
}
Int_t AliITStrackerV2::LoadClusters(TTree *cTree) {
branch->SetAddress(&clusters);
Int_t j=0;
- for (Int_t i=0; i<kMaxLayer; i++) {
+ for (Int_t i=0; i<AliITSgeomTGeo::GetNLayers(); i++) {
Int_t ndet=fgLayers[i].GetNdetectors();
Int_t jmax = j + fgLayers[i].GetNladders()*ndet;
//--------------------------------------------------------------------
//This function unloads ITS clusters
//--------------------------------------------------------------------
- for (Int_t i=0; i<kMaxLayer; i++) fgLayers[i].ResetClusters();
+ for (Int_t i=0; i<AliITSgeomTGeo::GetNLayers(); i++) fgLayers[i].ResetClusters();
}
static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
return 0;
}
-Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) {
+Int_t AliITStrackerV2::Clusters2Tracks(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions reconstructs ITS tracks
// The clusters must be already loaded !
if (esd->GetStatus()&AliESDtrack::kTPCout) continue;
if (esd->GetStatus()&AliESDtrack::kITSin) continue;
- AliITStrackV2 *t=0;
- try {
- t=new AliITStrackV2(*esd);
- } catch (const Char_t *msg) {
- Warning("Clusters2Tracks",msg);
- delete t;
- continue;
- }
+ AliITStrackV2 *t = new AliITStrackV2(*esd);
+
if (TMath::Abs(t->GetD(GetX(),GetY()))>4) {
delete t;
continue;
ResetTrackToFollow(*t);
ResetBestTrack();
- for (FollowProlongation(); fI<kMaxLayer; fI++) {
+ for (FollowProlongation(); fI<AliITSgeomTGeo::GetNLayers(); fI++) {
while (TakeNextProlongation()) FollowProlongation();
}
return 0;
}
-Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
+Int_t AliITStrackerV2::PropagateBack(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions propagates reconstructed ITS tracks back
// The clusters must be loaded !
if ((esd->GetStatus()&AliESDtrack::kITSin)==0) continue;
if (esd->GetStatus()&AliESDtrack::kITSout) continue;
- AliITStrackV2 *t=0;
- try {
- t=new AliITStrackV2(*esd);
- } catch (const Char_t *msg) {
- Warning("PropagateBack",msg);
- delete t;
- continue;
- }
+ AliITStrackV2 *t = new AliITStrackV2(*esd);
ResetTrackToFollow(*t);
if (fTrackToFollow.PropagateToVertex(event->GetVertex())) {
fTrackToFollow.StartTimeIntegral();
}
- fTrackToFollow.PropagateTo(3.,-0.0028,65.19);
+ Bool_t okProp=fTrackToFollow.PropagateTo(3.,-0.0028,65.19);
+ if(!okProp){
+ AliWarning("Propagation to beam pipe radius failed");
+ }
}
fTrackToFollow.ResetCovariance(10.); fTrackToFollow.ResetClusters();
return 0;
}
-Int_t AliITStrackerV2::RefitInward(AliESD *event) {
+Int_t AliITStrackerV2::RefitInward(AliESDEvent *event) {
//--------------------------------------------------------------------
// This functions refits ITS tracks using the
// "inward propagated" TPC tracks
if (esd->GetStatus()&AliESDtrack::kTPCout)
if ((esd->GetStatus()&AliESDtrack::kTPCrefit)==0) continue;
- AliITStrackV2 *t=0;
- try {
- t=new AliITStrackV2(*esd);
- } catch (const Char_t *msg) {
- Warning("RefitInward",msg);
- delete t;
- continue;
- }
+ AliITStrackV2 *t = new AliITStrackV2(*esd);
if (CorrectForDeadZoneMaterial(t)!=0) {
Warning("RefitInward",
CookLabel(&fTrackToFollow,0.); //For comparison only
if (fTrackToFollow.PropagateTo(3.,0.0028,65.19)) {//The beam pipe
+ fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSrefit);
AliESDtrack *esdTrack =fTrackToFollow.GetESDtrack();
- esdTrack->UpdateTrackParams(&fTrackToFollow,AliESDtrack::kITSrefit);
- Float_t r[3]={0.,0.,0.};
+ Double_t r[3]={0.,0.,0.};
Double_t maxD=3.;
esdTrack->RelateToVertex(event->GetVertex(),GetBz(r),maxD);
ntrk++;
if (TMath::Abs(fTrackToFollow.GetD(GetX(),GetY()))>4) return 0;
fTrackToFollow.
- SetSampledEdx(cc->GetQ(),fTrackToFollow.GetNumberOfClusters()-1); //b.b.
+ SetSampledEdx(cc->GetQ(),fI-2); //b.b.
{
Double_t x0;
//--------------------------------------------------------------------
for (Int_t i=0; i<kNsector; i++) fN[i]=0;
-
+ for (Int_t i=0; i<AliITSRecoParam::kMaxClusterPerLayer; i++){
+ fClusters[i]=0;
+ fIndex[i]=0;
+ }
}
AliITStrackerV2::AliITSlayer::
for (Int_t i=0; i<kNsector; i++) fN[i]=0;
- for (Int_t i=0; i<kMaxClusterPerLayer; i++) fClusters[i]=0;
-
+ for (Int_t i=0; i<AliITSRecoParam::kMaxClusterPerLayer; i++){
+ fClusters[i]=0;
+ fIndex[i]=0;
+ }
}
AliITStrackerV2::AliITSlayer::~AliITSlayer() {
// If "extra"==kTRUE,
// the clusters from overlapped modules get attached to "t"
//--------------------------------------------------------------------
- Int_t index[kMaxLayer];
+ Int_t index[AliITSgeomTGeo::kNLayers];
Int_t k;
- for (k=0; k<kMaxLayer; k++) index[k]=-1;
+ for (k=0; k<AliITSgeomTGeo::GetNLayers(); k++) index[k]=-1;
Int_t nc=c->GetNumberOfClusters();
for (k=0; k<nc; k++) {
Int_t idx=c->GetClusterIndex(k),nl=(idx&0xf0000000)>>28;
Int_t from, to, step;
if (xx > t->GetX()) {
- from=0; to=kMaxLayer;
+ from=0; to=AliITSgeomTGeo::GetNLayers();
step=+1;
} else {
- from=kMaxLayer-1; to=-1;
+ from=AliITSgeomTGeo::GetNLayers()-1; to=-1;
step=-1;
}
{
Double_t hI=i-0.5*step;
- if (TMath::Abs(hI-1.5)<0.01 || TMath::Abs(hI-3.5)<0.01) {
- Double_t rs=0.5*(fgLayers[i-step].GetR() + r);
- Double_t d=0.0034, x0=38.6;
- if (TMath::Abs(hI-1.5)<0.01) {rs=9.; d=0.0097; x0=42;}
- if (!t->PropagateTo(rs,-step*d,x0)) {
- return kFALSE;
- }
+ if (TMath::Abs(hI-1.5)<0.01 || TMath::Abs(hI-3.5)<0.01) {
+ Int_t iLay = i-step;
+ Double_t rs = 0.;
+ if(iLay<0 || iLay>= AliITSgeomTGeo::kNLayers){
+ AliError(Form("Invalid layer %d ",iLay));
+ return kFALSE;
+ }
+ else{
+ rs=0.5*(fgLayers[i-step].GetR() + r);
+ }
+ Double_t d=0.0034, x0=38.6;
+ if (TMath::Abs(hI-1.5)<0.01) {rs=9.; d=0.0097; x0=42;}
+ if (!t->PropagateTo(rs,-step*d,x0)) {
+ return kFALSE;
+ }
}
}
Int_t idx=index[i];
if (idx>=0) {
- const AliITSRecPoint *c=(AliITSRecPoint *)GetCluster(idx);
- if (idet != c->GetDetectorIndex()) {
- idet=c->GetDetectorIndex();
- const AliITSdetector &det=layer.GetDetector(idet);
- if (!t->Propagate(det.GetPhi(),det.GetR())) {
+ const AliITSRecPoint *ccc=(AliITSRecPoint *)GetCluster(idx);
+ if (idet != ccc->GetDetectorIndex()) {
+ idet=ccc->GetDetectorIndex();
+ const AliITSdetector &det2=layer.GetDetector(idet);
+ if (!t->Propagate(det2.GetPhi(),det2.GetR())) {
return kFALSE;
}
t->SetDetectorIndex(idet);
}
- Double_t chi2=t->GetPredictedChi2(c);
+ Double_t chi2=t->GetPredictedChi2(ccc);
if (chi2<maxchi2) {
- cl=c;
+ cl=ccc;
maxchi2=chi2;
} else {
return kFALSE;
if (!t->Update(cl,maxchi2,idx)) {
return kFALSE;
}
- t->SetSampledEdx(cl->GetQ(),t->GetNumberOfClusters()-1);
+ t->SetSampledEdx(cl->GetQ(),i-2);
}
{
Double_t ymax=t->GetY() + phi*r + dy;
layer.SelectClusters(zmin,zmax,ymin,ymax);
- const AliITSRecPoint *c=0; Int_t ci=-1,cci=-1;
- Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(), tolerance=0.1;
- while ((c=layer.GetNextCluster(ci))!=0) {
- if (idet == c->GetDetectorIndex()) continue;
+ const AliITSRecPoint *cx=0; Int_t ci=-1,cci=-1;
+ maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2();
+ Double_t tolerance=0.1;
+ while ((cx=layer.GetNextCluster(ci))!=0) {
+ if (idet == cx->GetDetectorIndex()) continue;
- const AliITSdetector &det=layer.GetDetector(c->GetDetectorIndex());
+ const AliITSdetector &detx=layer.GetDetector(cx->GetDetectorIndex());
- if (!tmp.Propagate(det.GetPhi(),det.GetR())) continue;
+ if (!tmp.Propagate(detx.GetPhi(),detx.GetR())) continue;
- if (TMath::Abs(tmp.GetZ() - c->GetZ()) > tolerance) continue;
- if (TMath::Abs(tmp.GetY() - c->GetY()) > tolerance) continue;
+ if (TMath::Abs(tmp.GetZ() - cx->GetZ()) > tolerance) continue;
+ if (TMath::Abs(tmp.GetY() - cx->GetY()) > tolerance) continue;
- Double_t chi2=tmp.GetPredictedChi2(c);
+ Double_t chi2=tmp.GetPredictedChi2(cx);
if (chi2<maxchi2) { maxchi2=chi2; cci=ci; }
}
if (cci>=0) t->SetExtraCluster(i,(i<<28)+cci);