///////////////////////////////////////////////////////////////////////////
-#include <stdlib.h>
+// #include <stdlib.h>
#include "AliITSclusterTable.h"
#include "AliITSclusterV2.h"
#include "AliITSgeom.h"
#include<TClonesArray.h>
#include<TTree.h>
ClassImp(AliITSclusterTable)
-
//__________________________________________________________
AliITSclusterTable::AliITSclusterTable(){
// Default constructor
fSyList =0;
fSzList =0;
}
-
//______________________________________________________________________
AliITSclusterTable::AliITSclusterTable(const AliITSclusterTable &tab) :
TObject(tab) {
fDet = new TArrayI*[nm];
TArrayI** vect = new TArrayI*[fGeom->GetNlayers()];
-
Int_t * firstmod = new Int_t[fGeom->GetNlayers()+1];
firstmod[fGeom->GetNlayers()]=fGeom->GetIndexMax(); // upper limit
for(Int_t nlayer=0;nlayer<fGeom->GetNlayers();nlayer++){
TClonesArray* clus = new TClonesArray("AliITSclusterV2",10000);
brancht->SetAddress(&clus);
-
for(Int_t mod=0;mod<nm;mod++){
Int_t nc=0;
clusterTree->GetEvent(mod);
else {
for(Int_t n=0;n<vect[nlr]->GetSize();n++){
Int_t mm=vect[nlr]->At(n);
- if (nc>=fDet[mod]->GetSize()) fDet[mod]->Set(nc*2+10);
+ if(nc>=fDet[mod]->GetSize()) fDet[mod]->Set(nc*2+10);
if(mm==mod) {(*fDet[mod])[nc]=n; nc+=1; }
}
}
}
-
clus->Delete();
delete clus;
for(Int_t n=0;n<fGeom->GetNlayers();n++)delete vect[n];
void AliITSclusterTable::FillArrayLabel(Int_t numberofparticles){
//
-
fLbl = new TArrayI*[numberofparticles];
const Int_t knm =fGeom->GetNlayers();
for(Int_t nlab=0;nlab<numberofparticles;nlab++){
void AliITSclusterTable::FillArrayCoorAngles(){
//Fill arrays with phi,lambda and indices of clusters for each layer
- Info("FillArrayCoorAngles","Filling Array...");
-
+
fPhiList = new TArrayD*[fGeom->GetNlayers()];
fLambdaList = new TArrayD*[fGeom->GetNlayers()];
- fXList = new TArrayD*[fGeom->GetNlayers()];
- fYList = new TArrayD*[fGeom->GetNlayers()];
- fZList = new TArrayD*[fGeom->GetNlayers()];
- fSxList = new TArrayD*[fGeom->GetNlayers()];
- fSyList = new TArrayD*[fGeom->GetNlayers()];
- fSzList = new TArrayD*[fGeom->GetNlayers()];
+ fXList = new TArrayF*[fGeom->GetNlayers()];
+ fYList = new TArrayF*[fGeom->GetNlayers()];
+ fZList = new TArrayF*[fGeom->GetNlayers()];
+ fSxList = new TArrayF*[fGeom->GetNlayers()];
+ fSyList = new TArrayF*[fGeom->GetNlayers()];
+ fSzList = new TArrayF*[fGeom->GetNlayers()];
Int_t * firstmod = new Int_t[fGeom->GetNlayers()+1];
firstmod[fGeom->GetNlayers()]=fGeom->GetIndexMax(); // upper limit
Int_t ncl = fTracker->GetNumberOfClustersLayer(nlay);
fPhiList[nlay] = new TArrayD(ncl);
fLambdaList[nlay]=new TArrayD(ncl);
- fXList[nlay]=new TArrayD(ncl);
- fYList[nlay]=new TArrayD(ncl);
- fZList[nlay]=new TArrayD(ncl);
- fSxList[nlay]=new TArrayD(ncl);
- fSyList[nlay]=new TArrayD(ncl);
- fSzList[nlay]=new TArrayD(ncl);
+ fXList[nlay]=new TArrayF(ncl);
+ fYList[nlay]=new TArrayF(ncl);
+ fZList[nlay]=new TArrayF(ncl);
+ fSxList[nlay]=new TArrayF(ncl);
+ fSyList[nlay]=new TArrayF(ncl);
+ fSzList[nlay]=new TArrayF(ncl);
for(Int_t j=0;j<ncl;j++){
AliITSclusterV2* cl = fTracker->GetClusterLayer(nlay,j);
Double_t phi=0;Double_t lambda=0;
- Double_t x=0;Double_t y=0;Double_t z=0;
- Double_t sx=0;Double_t sy=0;Double_t sz=0;
+ Float_t x=0;Float_t y=0;Float_t z=0;
+ Float_t sx=0;Float_t sy=0;Float_t sz=0;
Int_t module = cl->GetDetectorIndex()+firstmod[nlay];
GetCoorAngles(cl,module,phi,lambda,x,y,z);
GetCoorErrors(cl,module,sx,sy,sz);
delete [] firstmod;
}
-
-void AliITSclusterTable::GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda, Double_t &x, Double_t &y,Double_t &z){
+void AliITSclusterTable::GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda, Float_t &x, Float_t &y,Float_t &z){
//Returns values of phi (azimuthal) and lambda angles for a given cluster
Double_t rot[9]; fGeom->GetRotMatrix(module,rot);
Double_t phi1=TMath::Pi()/2+alpha;
if (lay==1) phi1+=TMath::Pi();
- Double_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
- Double_t r=tx*cp+ty*sp;
+ Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1);
+ Float_t r=tx*cp+ty*sp;
x= r*cp - cl->GetY()*sp;
y= r*sp + cl->GetY()*cp;
lambda=TMath::ATan2(z-fPrimaryVertex[2],TMath::Sqrt((x-fPrimaryVertex[0])*(x-fPrimaryVertex[0])+(y-fPrimaryVertex[1])*(y-fPrimaryVertex[1])));
}
-void AliITSclusterTable::GetCoorErrors(AliITSclusterV2* cl, Int_t module,Double_t &sx,Double_t &sy, Double_t &sz){
+void AliITSclusterTable::GetCoorErrors(AliITSclusterV2* cl, Int_t module,Float_t &sx,Float_t &sy, Float_t &sz){
//returns x,y,z of cluster in global coordinates
Double_t phi=TMath::Pi()/2+alpha;
if (lay==1) phi+=TMath::Pi();
- Double_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
+ Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi);
-
sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2());
sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2());
sz = TMath::Sqrt(cl->GetSigmaZ2());
#include <TArrayI.h>
#include <TArrayD.h>
+#include <TArrayF.h>
#include <TObject.h>
class TTree;
void FillArray(TTree* clusterTree);
void FillArrayLabel(Int_t numberofparticles);
void FillArrayCoorAngles();
- void GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda,Double_t &x,Double_t &y,Double_t &z);
- void GetCoorErrors(AliITSclusterV2* cl, Int_t module,Double_t &sx,Double_t &sy, Double_t &sz);
+ void GetCoorAngles(AliITSclusterV2* cl,Int_t module,Double_t &phi,Double_t &lambda,Float_t &x,Float_t &y,Float_t &z);
+ void GetCoorErrors(AliITSclusterV2* cl, Int_t module,Float_t &sx,Float_t &sy, Float_t &sz);
virtual ~AliITSclusterTable();
Int_t ThisParticleIsTrackable(Int_t label,Int_t numberofpoints=6);
Double_t GetPhiCluster(Int_t layer, Int_t i){return fPhiList[layer]->At(i);}
Double_t GetLambdaCluster(Int_t layer, Int_t i) {return fLambdaList[layer]->At(i);}
- Double_t GetXCluster(Int_t layer, Int_t i){return fXList[layer]->At(i);}
- Double_t GetYCluster(Int_t layer, Int_t i) {return fYList[layer]->At(i);}
- Double_t GetZCluster(Int_t layer, Int_t i) {return fZList[layer]->At(i);}
- Double_t GetXClusterError(Int_t layer, Int_t i) {return fSxList[layer]->At(i);}
- Double_t GetYClusterError(Int_t layer, Int_t i) {return fSyList[layer]->At(i);}
- Double_t GetZClusterError(Int_t layer, Int_t i) {return fSzList[layer]->At(i);}
+ Float_t GetXCluster(Int_t layer, Int_t i){return fXList[layer]->At(i);}
+ Float_t GetYCluster(Int_t layer, Int_t i) {return fYList[layer]->At(i);}
+ Float_t GetZCluster(Int_t layer, Int_t i) {return fZList[layer]->At(i);}
+ Float_t GetXClusterError(Int_t layer, Int_t i) {return fSxList[layer]->At(i);}
+ Float_t GetYClusterError(Int_t layer, Int_t i) {return fSyList[layer]->At(i);}
+ Float_t GetZClusterError(Int_t layer, Int_t i) {return fSzList[layer]->At(i);}
TArrayI* GetListOfClusters(Int_t mod) const {return fDet[mod];}
TArrayI* GetNClustersSameLabel(Int_t label) const {return fLbl[label];}
TArrayD* GetListOfPhi(Int_t layer) const {return fPhiList[layer];}
TArrayD* GetListOfLambda(Int_t layer) const {return fLambdaList[layer];}
- TArrayD* GetListOfX(Int_t layer) const {return fXList[layer];}
- TArrayD* GetListOfY(Int_t layer) const {return fYList[layer];}
- TArrayD* GetListOfZ(Int_t layer) const {return fZList[layer];}
- TArrayD* GetListOfSx(Int_t layer)const {return fSxList[layer];}
- TArrayD* GetListOfSy(Int_t layer)const {return fSyList[layer];}
- TArrayD* GetListOfSz(Int_t layer)const {return fSzList[layer];}
+ TArrayF* GetListOfX(Int_t layer) const {return fXList[layer];}
+ TArrayF* GetListOfY(Int_t layer) const {return fYList[layer];}
+ TArrayF* GetListOfZ(Int_t layer) const {return fZList[layer];}
+ TArrayF* GetListOfSx(Int_t layer)const {return fSxList[layer];}
+ TArrayF* GetListOfSy(Int_t layer)const {return fSyList[layer];}
+ TArrayF* GetListOfSz(Int_t layer)const {return fSzList[layer];}
protected:
// copy constructor (NO copy allowed: the constructor is protected
// with the same label for each label.
TArrayD** fPhiList; //Array of cluster azimuthal angles on each layer
TArrayD** fLambdaList;//Array of cluster Lambda angles on each layer
- TArrayD** fXList; //Array of cluster x coordinates on each layer
- TArrayD** fYList; //Array of cluster y coordinates on each layer
- TArrayD** fZList; // Array of cluster z coordinates on each layer
- TArrayD** fSxList; //Array of cluster errors on x on each layer
- TArrayD** fSyList; //Array of cluster errors on y on each layer
- TArrayD** fSzList; //Array of cluster errors on z on each layer
+ TArrayF** fXList; //Array of cluster x coordinates on each layer
+ TArrayF** fYList; //Array of cluster y coordinates on each layer
+ TArrayF** fZList; // Array of cluster z coordinates on each layer
+ TArrayF** fSxList; //Array of cluster errors on x on each layer
+ TArrayF** fSyList; //Array of cluster errors on y on each layer
+ TArrayF** fSzList; //Array of cluster errors on z on each layer
AliITSgeom *fGeom; //! ITS geometry
AliITStrackerSA *fTracker; //! SA tracker
+
/**************************************************************************
* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
* *
// tracks are saved as AliITStrackV2 objects //
////////////////////////////////////////////////////
-#include <stdlib.h>
#include "TArrayI.h"
#include <TBranch.h>
#include <TMath.h>
}
fVertexer = tracker.fVertexer;
fGeom = tracker.fGeom;
- fFlagLoad = tracker.fFlagLoad;
fTable = tracker.fTable;
+ fListOfTracks = tracker.fListOfTracks;
}
//____________________________________________________________________________
fVert = 0;
fVertexer = 0;
fGeom = 0;
- fFlagLoad = 0;
if(fPhiWin)delete []fPhiWin;
if(fLambdaWin)delete []fLambdaWin;
fTable =0;
-}
+ fListOfTracks->Delete();
+ }
//____________________________________________________________________________
void AliITStrackerSA::Init(){
fVert = 0;
fVertexer = 0;
fGeom = 0;
- fFlagLoad = 0;
SetWindowSizes();
fTable = 0;
fITSclusters = 0;
SetSixPoints();
+ fListOfTracks=new TObjArray(0,0);
}
//_______________________________________________________________________
void AliITStrackerSA::ResetForFinding(){
fCoef3=0;
fPointc[0]=0;
fPointc[1]=0;
+ fListOfTracks->Delete();
}
//____________________________________________________________________________
void AliITStrackerSA::FindTracks(TTree *out,Int_t evnumber){
AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
if(kl->IsUsed()==1) kl->Use();
}
- continue;
+ continue;
}
outrack=tr2;
out->Fill();
// Track finder using the ESD object
+
if(!fITSclusters){
Fatal("FindTracks","ITS cluster tree is not accessed - Abort!!!\n Please use method SetClusterTree to pass the pointer to the tree\n");
return -1;
}
//Fill array with cluster indices for each module
- fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
- fTable->FillArray(fITSclusters);
- fTable->FillArrayCoorAngles();
-
+ if(!fTable){
+ fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
+ fTable->FillArray(fITSclusters);
+ fTable->FillArrayCoorAngles();
+ }
Int_t * firstmod = new Int_t[fGeom->GetNlayers()];
for(Int_t i=0;i<fGeom->GetNlayers();i++){
AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
if(kl->IsUsed()==1) kl->Use();
}
- continue;
+ continue;
}
AliESDtrack outtrack;
outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
event->AddTrack(&outtrack);
-
ntrack++;
Int_t nct = tr2->GetNumberOfClusters();
while(nct--){
Int_t index = tr2->GetClusterIndex(nct);
AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
if(kl->IsUsed()==0) kl->Use();
+
}
}
else{
Int_t index = trs->GetClusterIndexSA(nct);
AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
if(kl->IsUsed()==1) kl->Use();
- }
+ }
}
delete trs;
delete[] nn;
AliITSclusterV2* kl = (AliITSclusterV2*)GetCluster(index);
if(kl->IsUsed()==1) kl->Use();
}
+
continue;
}
AliESDtrack outtrack;
outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin);
event->AddTrack(&outtrack);
-
Int_t nct = tr2->GetNumberOfClusters();
while(nct--){
Int_t index = tr2->GetClusterIndex(nct);
for(Int_t i=0;i<fGeom->GetNlayers();i++){
firstmod[i]=fGeom->GetModuleIndex(i+1,1,1);
}
- TObjArray* listoftracks=new TObjArray(0,0);
AliITStrackV2* otrack2;
Int_t nclusters = tr->GetNumberOfClustersSA();
TObjArray** listlayer = new TObjArray*[fGeom->GetNlayers()];
otrack2->ResetCovariance();
otrack2->ResetClusters();
//fit from layer 6 to layer 1
- if(RefitAt(3.7,otrack2,ot)) listoftracks->AddLast(otrack2);
+ if(RefitAt(3.7,otrack2,ot)) fListOfTracks->AddLast(otrack2);
}
delete [] end;
- Int_t dim=listoftracks->GetEntries();
+ Int_t dim=fListOfTracks->GetEntries();
if(dim==0){
- delete listoftracks;
for(Int_t i=0;i<fGeom->GetNlayers();i++){
delete listlayer[i];
}
return 0;
}
- AliITStrackV2* otrack =(AliITStrackV2*)FindTrackLowChiSquare(listoftracks,dim);
+ AliITStrackV2* otrack =(AliITStrackV2*)FindTrackLowChiSquare(fListOfTracks,dim);
if(otrack==0) return 0;
Int_t * indexc = new Int_t[fGeom->GetNlayers()];
cl4->GetLabel(2),labl[2],numberofpoints);
otrack->SetLabel(label);
- delete listoftracks;
for(Int_t i=0;i<fGeom->GetNlayers();i++){
delete listlayer[i];
}
}
//_______________________________________________________________________
-void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,TTree* treev2, TTree* clustertree){
+void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,TTree* treev2){
// Marks as used clusters belonging to tracks found with V2 TPC+ITS tracking
//(or AliITStrackV2 tracks found with function FindTracks of this class)
+
//Get primary vertex
if(fVertexer){
fTable->FillArray(fITSclusters);
fTable->FillArrayCoorAngles();
}
- SetEventNumber(evnum);
- if(GetFlagLoadedClusters()==0) LoadClusters(clustertree);
- SetFlagLoadedClusters(1);
TBranch* bra = (TBranch*)treev2->GetBranch("tracks");
if(!bra) Warning("UseFoundTracksV2","No branch for track tree");
}
//_______________________________________________________________________
-void AliITStrackerSA::UseFoundTracksV2(Int_t evnum,AliESD *event, TTree*
-clustertree){
+void AliITStrackerSA::UseFoundTracksV2(AliESD *event){
// Marks as used clusters belonging to tracks found with V2 TPC+ITS tracking
//Get primary vertex
- if(fVertexer){
- if(fVert)delete fVert;
- fVert = fVertexer->FindVertexForCurrentEvent(evnum);
- }
- else {
- gAlice->GetEvent(evnum);
- if(!fVert){
- Fatal("FindTracks","Vertex is missing\n");
- return;
- }
- }
+
Double_t primaryVertex[3];
- fVert->GetXYZ(primaryVertex);
+ event->GetVertex()->GetXYZ(primaryVertex);
if(!fTable){
fTable = new AliITSclusterTable(fGeom,this,primaryVertex);
fTable->FillArray(fITSclusters);
fTable->FillArrayCoorAngles();
}
- SetEventNumber(evnum);
- if(GetFlagLoadedClusters()==0) LoadClusters(clustertree);
- SetFlagLoadedClusters(1);
+
Int_t ntracks = event->GetNumberOfTracks();
while (ntracks--) {
AliESDtrack *esd=event->GetTrack(ntracks);
Int_t nm[8]={0,0,0,0,0,0,0,0};
nm[0] = lay.FindDetectorIndex(fi+phiwindow,zed);
nm[1] = lay.FindDetectorIndex(fi-phiwindow,zed);
- nm[2] = lay.FindDetectorIndex(fi,zed1);
- nm[3] = lay.FindDetectorIndex(fi,zed2);
- nm[4] = lay.FindDetectorIndex(fi+phiwindow,zed1);
- nm[5] = lay.FindDetectorIndex(fi-phiwindow,zed1);
- nm[6] = lay.FindDetectorIndex(fi+phiwindow,zed2);
- nm[7] = lay.FindDetectorIndex(fi-phiwindow,zed2);
+ nm[2] = lay.FindDetectorIndex(fi,zed1);
+ nm[3] = lay.FindDetectorIndex(fi,zed2);
+ nm[4] = lay.FindDetectorIndex(fi+phiwindow,zed1);
+ nm[5] = lay.FindDetectorIndex(fi-phiwindow,zed1);
+ nm[6] = lay.FindDetectorIndex(fi+phiwindow,zed2);
+ nm[7] = lay.FindDetectorIndex(fi-phiwindow,zed2);
+
Int_t nn=0;
TArrayI* array =(TArrayI*)table->GetListOfClusters(nmod);
- TArrayI* list = new TArrayI(array->GetSize());
+ TArrayI* listc = new TArrayI(array->GetSize());
for(Int_t i=0;i<array->GetSize();i++){
Int_t in=(Int_t)array->At(i);
- list->AddAt(in,nn);
+ listc->AddAt(in,nn);
nn++;
}
-// Info("SearchClusters", "layer %d, module %d", layer, nmod);
+ Int_t k=0;
+ Int_t val;
+ while(k<8){
+ for(Int_t h=k+1;h<8;h++){
+ if(nm[k]>nm[h]){
+ val=nm[k];
+ nm[k]=nm[h];
+ nm[h]=val;
+ }
+
+ }
+ k++;
+ }
+
+ Int_t value=-5;
+
for(Int_t ii=0;ii<8;ii++){
- if(nm[ii]!=nmod && nm[ii]>=0){
+ if(nm[ii]!=value && nm[ii]!=nmod && nm[ii]>=0){
TArrayI* ar =(TArrayI*)table->GetListOfClusters(nm[ii]+firstmod[layer]);
- list->Set(list->GetSize()+ar->GetSize());
+ listc->Set(listc->GetSize()+ar->GetSize());
for(Int_t j=0;j<ar->GetSize();j++){
- Int_t in=(Int_t)ar->At(j);
- list->AddAt(in,nn);
- nn++;
+ Int_t in=(Int_t)ar->At(j);
+ listc->AddAt(in,nn);
+ nn++;
+ value=nm[ii];
}
}
}
- for(Int_t i=0;i<list->GetSize();i++){
- Int_t index = (Int_t)list->At(i);
+
+
+ for(Int_t i=0;i<listc->GetSize();i++){
+ Int_t index = (Int_t)listc->At(i);
AliITSclusterV2* cllay = lay.GetCluster(index);
if(cllay==0) continue;
if(cllay->IsUsed()==1) continue;
TMath::Abs(fPhiEstimate-phi)<phiwindow){
nc+=1;
fLambdac = lambda;
- if(trs->GetNumberOfClustersSA()==20){
+ if(trs->GetNumberOfClustersSA()==15){
delete[] firstmod;
- delete list;
+ delete listc;
return 0;
}
trs->AddClusterSA(layer,index);
}
}
- delete list;
+ delete listc;
delete [] firstmod;
return nc;
}
else { // default values
- Double_t phid[40] = {0.001,0.0015,0.002,0.0023,0.0025,0.0027,0.003,
- 0.0033,0.0035,0.0037,0.004,0.0043,0.0045,0.0047,
+ Double_t phid[32] = {0.002,0.003,0.004,0.0045,0.0047,
0.005,0.0053,0.0055,
0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
0.01,0.0105,0.011,0.0115,0.012,0.0125,0.013,0.0135,
0.014};
- Double_t lambdad[40] = {0.001,0.0015,0.002,0.0023,0.0025,0.0027,0.003,
- 0.0033,0.0035,0.0037,0.004,0.0043,0.0045,0.0047,
+ Double_t lambdad[32] = {0.002,0.003,0.004,0.0045,0.0047,
0.005,0.0053,0.0055,
0.006,0.0063,0.0065,0.007,0.0073,0.0075,0.0077,
0.008,0.0083,0.0085,0.0087,0.009,0.0095,0.0097,
0.01,0.015,0.011,0.0115,0.012,0.0125,0.013,0.0135,
0.014};
- if(fNloop!=40){
- fNloop = 40;
- Warning("SetWindowSizes","Number of loop forced to the default value %d",fNloop);
+ if(fNloop!=32){
+ fNloop = 32;
}
fPhiWin = new Double_t[fNloop];
void SetSixPoints(Bool_t sp = kTRUE){fSixPoints = sp;}
Bool_t GetSixPoints() const {return fSixPoints;}
void SetWindowSizes(Int_t n=46, Double_t *phi=0, Double_t *lam=0);
- void UseFoundTracksV2(Int_t evnum,TTree* treev2, TTree* clustertree);
- void UseFoundTracksV2(Int_t evnum,AliESD *event, TTree* clustertree);
+ void UseFoundTracksV2(Int_t evnum,TTree* treev2);
+ void UseFoundTracksV2(AliESD *event);
protected:
AliITStrackerSA& operator=(const AliITStrackerSA& /* trkr */);
//Initialization
void Init();
- Int_t GetFlagLoadedClusters() const {return fFlagLoad;}
-
- void ResetForFinding();
- void SetFlagLoadedClusters(Int_t d) {fFlagLoad=d;}
-
- void UpdatePoints();
+ void ResetForFinding();
+ void UpdatePoints();
static Double_t Curvature(Double_t x1,Double_t y1,Double_t x2,Double_t y2,
Double_t x3,Double_t y3);
Double_t fPhiEstimate; //Estimation of phi angle on next layer
- Double_t fPoint1[2]; //! coord. of 1-st point to evaluate the curvature
- Double_t fPoint2[2]; //! coord. of 2-nd point to evaluate the curvature
- Double_t fPoint3[2]; //! coord. of 3-rd point to evaluate the curvature
- Double_t fPointc[2]; //! current point coord (for curvature eval.)
+ Float_t fPoint1[2]; //! coord. of 1-st point to evaluate the curvature
+ Float_t fPoint2[2]; //! coord. of 2-nd point to evaluate the curvature
+ Float_t fPoint3[2]; //! coord. of 3-rd point to evaluate the curvature
+ Float_t fPointc[2]; //! current point coord (for curvature eval.)
Double_t fLambdac; //! current value of the Lambda angle in the window
Double_t fPhic; //! current value of the Phi angle in the window
Float_t fCoef1; //! param. of the equation of the circ. approx a layer
AliESDVertex *fVert; //! primary vertex
AliITSVertexer *fVertexer; //! vertexer
AliITSgeom *fGeom; //! ITS geometry
+ TObjArray *fListOfTracks; //! container for found tracks
TTree *fITSclusters; //! pointer to ITS tree of clusters
- Int_t fFlagLoad; // flag for loaded clusters (1==already loaded)
Bool_t fSixPoints; // If true 6/6 points are required (default). 5/6 otherwise
AliITSclusterTable* fTable; // table with clusters
ClassDef(AliITStrackerSA,1)