#include <new>
+#include <TError.h>
#include <TFile.h>
#include <TTree.h>
#include <TRandom.h>
#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)
fConstraint[0]=1; fConstraint[1]=0;
- Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV};
+ Double_t xyz[]={AliITSReconstructor::GetRecoParam()->GetXVdef(),
+ AliITSReconstructor::GetRecoParam()->GetYVdef(),
+ AliITSReconstructor::GetRecoParam()->GetZVdef()};
+ Double_t ers[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(),
+ AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(),
+ AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()};
SetVertex(xyz,ers);
for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=kLayersNotToSkip[i];
fConstraint[0]=t.fConstraint[0]; fConstraint[1]=t.fConstraint[1];
- Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV};
+ Double_t xyz[]={AliITSReconstructor::GetRecoParam()->GetXVdef(),
+ AliITSReconstructor::GetRecoParam()->GetYVdef(),
+ AliITSReconstructor::GetRecoParam()->GetZVdef()};
+ Double_t ers[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(),
+ AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(),
+ AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()};
xyz[0]=t.GetX(); xyz[1]=t.GetY(); xyz[2]=t.GetZ();
ers[0]=t.GetSigmaX(); ers[1]=t.GetSigmaY(); ers[2]=t.GetSigmaZ();
SetVertex(xyz,ers);
}
-AliITStrackerV2::AliITStrackerV2(const AliITSgeomTGeo *geom) :
+AliITStrackerV2::AliITStrackerV2(const Char_t *geom) :
AliTracker(),
fI(kMaxLayer),
fBestTrack(),
for (Int_t j=1; j<nlad+1; j++) {
for (Int_t k=1; k<ndet+1; k++) { //Fill this layer with detectors
TGeoHMatrix m; AliITSgeomTGeo::GetOrigMatrix(i,j,k,m);
- Double_t *xyz=m.GetTranslation(), x=xyz[0], y=xyz[1];
- Double_t *rot=m.GetRotationMatrix();
-
- Double_t phi=TMath::ATan2(rot[1],rot[0])+TMath::Pi();
- phi+=TMath::Pi()/2;
- if (i==1) phi+=TMath::Pi();
+ const TGeoHMatrix *tm=AliITSgeomTGeo::GetTracking2LocalMatrix(i,j,k);
+ m.Multiply(tm);
+ Double_t txyz[3]={0.}, xyz[3]={0.};
+ m.LocalToMaster(txyz,xyz);
+ Double_t 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();
else if (phi>=TMath::TwoPi()) phi-=TMath::TwoPi();
- Double_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
- Double_t r=x*cp+y*sp;
-
AliITSdetector &det=fgLayers[i-1].GetDetector((j-1)*ndet + k-1);
new(&det) AliITSdetector(r,phi);
}
fConstraint[0]=1; fConstraint[1]=0;
- Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV};
+ Double_t xyz[]={AliITSReconstructor::GetRecoParam()->GetXVdef(),
+ AliITSReconstructor::GetRecoParam()->GetYVdef(),
+ AliITSReconstructor::GetRecoParam()->GetZVdef()};
+ Double_t ers[]={AliITSReconstructor::GetRecoParam()->GetSigmaXVdef(),
+ AliITSReconstructor::GetRecoParam()->GetSigmaYVdef(),
+ AliITSReconstructor::GetRecoParam()->GetSigmaZVdef()};
SetVertex(xyz,ers);
for (Int_t i=0; i<kMaxLayer; i++) fLayersNotToSkip[i]=kLayersNotToSkip[i];
for (; j<jmax; j++) {
if (!cTree->GetEvent(j)) continue;
Int_t ncl=clusters->GetEntriesFast();
+
while (ncl--) {
AliITSRecPoint *c=(AliITSRecPoint*)clusters->UncheckedAt(ncl);
+ if (!c->Misalign()) AliWarning("Can't misalign this cluster !");
+
Int_t idx=c->GetDetectorIndex();
AliITSdetector &det=fgLayers[i].GetDetector(idx);
- //Shift the cluster to the misaligned position (temporary solution)
- Double_t x=det.GetR();
- if (i==0) x-=0.0075;
- else if (i==1) x+=0.0075;
- c->SetX(x);
-
Double_t y=r*det.GetPhi()+c->GetY();
if (y>circ) y-=circ; else if (y<0) y+=circ;
c->SetPhiR(y);
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 !
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 !
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
}
//find intersection
- Double_t x,y,z;
- if (!fTrackToFollow.GetGlobalXYZat(r,x,y,z)) {
+ Double_t phi,z;
+ if (!fTrackToFollow.GetPhiZat(r,phi,z)) {
//Warning("FollowProlongation","failed to estimate track !\n");
return;
}
- Double_t phi=TMath::ATan2(y,x);
Int_t idet=layer.FindDetectorIndex(phi,z);
if (idet<0) {
//Select possible prolongations and store the current track estimation
track.~AliITStrackV2(); new(&track) AliITStrackV2(fTrackToFollow);
- Double_t dz=7*TMath::Sqrt(track.GetSigmaZ2() + kSigmaZ2[i]);
- Double_t dy=7*TMath::Sqrt(track.GetSigmaY2() + kSigmaY2[i]);
+ Double_t dz=7*TMath::Sqrt(track.GetSigmaZ2() + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i));
+ Double_t dy=7*TMath::Sqrt(track.GetSigmaY2() + AliITSReconstructor::GetRecoParam()->GetSigmaY2(i));
Double_t road=layer.GetRoad();
if (dz*dy>road*road) {
Double_t dd=TMath::Sqrt(dz*dy), scz=dz/dd, scy=dy/dd;
dz=road*scz; dy=road*scy;
}
- //Double_t dz=4*TMath::Sqrt(track.GetSigmaZ2() + kSigmaZ2[i]);
+ //Double_t dz=4*TMath::Sqrt(track.GetSigmaZ2() + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i));
if (dz < 0.5*TMath::Abs(track.GetTgl())) dz=0.5*TMath::Abs(track.GetTgl());
- if (dz > kMaxRoad) {
+ if (dz > AliITSReconstructor::GetRecoParam()->GetMaxRoad()) {
//Warning("FollowProlongation","too broad road in Z !\n");
return;
}
if (TMath::Abs(fTrackToFollow.GetZ()-GetZ()) > r+dz) return;
- //Double_t dy=4*TMath::Sqrt(track.GetSigmaY2() + kSigmaY2[i]);
+ //Double_t dy=4*TMath::Sqrt(track.GetSigmaY2() + AliITSReconstructor::GetRecoParam()->GetSigmaY2(i));
if (dy < 0.5*TMath::Abs(track.GetSnp())) dy=0.5*TMath::Abs(track.GetSnp());
- if (dy > kMaxRoad) {
+ if (dy > AliITSReconstructor::GetRecoParam()->GetMaxRoad()) {
//Warning("FollowProlongation","too broad road in Y !\n");
return;
}
if (ncl)
if (ncl >= nclb) {
Double_t chi2=fTrackToFollow.GetChi2();
- if (chi2/ncl < kChi2PerCluster) {
+ if (chi2/ncl < AliITSReconstructor::GetRecoParam()->GetChi2PerCluster()) {
if (ncl > nclb || chi2 < fBestTrack.GetChi2()) {
ResetBestTrack();
}
AliITSlayer &layer=fgLayers[fI];
ResetTrackToFollow(fTracks[fI]);
- Double_t dz=7*TMath::Sqrt(fTrackToFollow.GetSigmaZ2() + kSigmaZ2[fI]);
- Double_t dy=7*TMath::Sqrt(fTrackToFollow.GetSigmaY2() + kSigmaY2[fI]);
+ Double_t dz=7*TMath::Sqrt(fTrackToFollow.GetSigmaZ2() + AliITSReconstructor::GetRecoParam()->GetSigmaZ2(fI));
+ Double_t dy=7*TMath::Sqrt(fTrackToFollow.GetSigmaY2() + AliITSReconstructor::GetRecoParam()->GetSigmaY2(fI));
Double_t road=layer.GetRoad();
if (dz*dy>road*road) {
Double_t dd=TMath::Sqrt(dz*dy), scz=dz/dd, scy=dy/dd;
const AliITSRecPoint *c=0; Int_t ci=-1;
const AliITSRecPoint *cc=0; Int_t cci=-1;
- Double_t chi2=kMaxChi2;
+ Double_t chi2=AliITSReconstructor::GetRecoParam()->GetMaxChi2();
while ((c=layer.GetNextCluster(ci))!=0) {
Int_t idet=c->GetDetectorIndex();
if (!cc) return 0;
- if (!fTrackToFollow.PropagateTo(cc->GetX(),0.,0.)) return 0; // Alignment
+ {// Take into account the mis-alignment
+ Double_t x = fTrackToFollow.GetX() + cc->GetX();
+ if (!fTrackToFollow.PropagateTo(x,0.,0.)) return 0;
+ }
if (!fTrackToFollow.Update(cc,chi2,(fI<<28)+cci)) {
//Warning("TakeNextProlongation","filtering failed !\n");
return 0;
//--------------------------------------------------------------------
//This function finds the detector crossed by the track
//--------------------------------------------------------------------
- Double_t dphi=-(phi-fPhiOffset);
+ Double_t dphi;
+ if (fZOffset<0) // old geometry
+ dphi = -(phi-fPhiOffset);
+ else // new geometry
+ dphi = phi-fPhiOffset;
+
if (dphi < 0) dphi += 2*TMath::Pi();
else if (dphi >= 2*TMath::Pi()) dphi -= 2*TMath::Pi();
Int_t np=Int_t(dphi*fNladders*0.5/TMath::Pi()+0.5);
}
//
- Double_t x,y,z;
- if (!t->GetGlobalXYZat(r,x,y,z)) {
+ Double_t phi,z;
+ if (!t->GetPhiZat(r,phi,z)) {
return kFALSE;
}
- Double_t phi=TMath::ATan2(y,x);
+
Int_t idet=layer.FindDetectorIndex(phi,z);
if (idet<0) {
return kFALSE;
t->SetDetectorIndex(idet);
const AliITSRecPoint *cl=0;
- Double_t maxchi2=kMaxChi2;
+ Double_t maxchi2=AliITSReconstructor::GetRecoParam()->GetMaxChi2();
Int_t idx=index[i];
- if (idx>0) {
+ if (idx>=0) {
const AliITSRecPoint *c=(AliITSRecPoint *)GetCluster(idx);
if (idet != c->GetDetectorIndex()) {
idet=c->GetDetectorIndex();
}
if (cl) {
- if (!t->PropagateTo(cl->GetX(),0.,0.)) return kFALSE; //Alignment
+ // Take into account the mis-alignment
+ Double_t x=t->GetX()+cl->GetX();
+ if (!t->PropagateTo(x,0.,0.)) return kFALSE;
if (!t->Update(cl,maxchi2,idx)) {
return kFALSE;
}
if (extra) { //search for extra clusters
AliITStrackV2 tmp(*t);
- Double_t dz=4*TMath::Sqrt(tmp.GetSigmaZ2()+kSigmaZ2[i]);
+ Double_t dz=4*TMath::Sqrt(tmp.GetSigmaZ2()+AliITSReconstructor::GetRecoParam()->GetSigmaZ2(i));
if (dz < 0.5*TMath::Abs(tmp.GetTgl())) dz=0.5*TMath::Abs(tmp.GetTgl());
- Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+kSigmaY2[i]);
+ Double_t dy=4*TMath::Sqrt(t->GetSigmaY2()+AliITSReconstructor::GetRecoParam()->GetSigmaY2(i));
if (dy < 0.5*TMath::Abs(tmp.GetSnp())) dy=0.5*TMath::Abs(tmp.GetSnp());
Double_t zmin=t->GetZ() - dz;
Double_t zmax=t->GetZ() + dz;
layer.SelectClusters(zmin,zmax,ymin,ymax);
const AliITSRecPoint *c=0; Int_t ci=-1,cci=-1;
- Double_t maxchi2=1000.*kMaxChi2, tolerance=0.1;
+ Double_t maxchi2=1000.*AliITSReconstructor::GetRecoParam()->GetMaxChi2(), tolerance=0.1;
while ((c=layer.GetNextCluster(ci))!=0) {
if (idet == c->GetDetectorIndex()) continue;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff