X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ITS%2FAliITStrackerSA.cxx;h=7fd94a7208f2562ca458ea4e4c4166b8cc4a2ad5;hb=f2fafc64fcbfadcbee202f56b48525a2019b58c0;hp=787a576434c21f6c709b92b878367668ec1d8cfe;hpb=00a7cc50a892d6950eb32c6eb20b2088fed1e164;p=u%2Fmrichter%2FAliRoot.git diff --git a/ITS/AliITStrackerSA.cxx b/ITS/AliITStrackerSA.cxx index 787a576434c..7fd94a7208f 100644 --- a/ITS/AliITStrackerSA.cxx +++ b/ITS/AliITStrackerSA.cxx @@ -29,93 +29,200 @@ #include #include -#include "AliESD.h" +#include "AliESDEvent.h" #include "AliESDVertex.h" #include "AliESDtrack.h" #include "AliITSVertexer.h" #include "AliITSclusterTable.h" #include "AliITSRecPoint.h" -#include "AliITSgeom.h" +#include "AliITSgeomTGeo.h" #include "AliITStrackSA.h" #include "AliITStrackerSA.h" +#include "AliITSReconstructor.h" +#include "AliLog.h" #include "AliRun.h" ClassImp(AliITStrackerSA) //____________________________________________________________________________ -AliITStrackerSA::AliITStrackerSA():AliITStrackerMI(){ +AliITStrackerSA::AliITStrackerSA():AliITStrackerMI(), +fPhiEstimate(0), +fITSStandAlone(0), +fLambdac(0), +fPhic(0), +fCoef1(0), +fCoef2(0), +fCoef3(0), +fNloop(0), +fPhiWin(0), +fLambdaWin(0), +fVert(0), +fVertexer(0), +fListOfTracks(0), +fListOfSATracks(0), +fITSclusters(0), +fInwardFlag(0), +fOuterStartLayer(0), +fInnerStartLayer(5), +fMinNPoints(0), +fMinQ(0.), +fCluLayer(0), +fCluCoord(0){ // Default constructor Init(); } //____________________________________________________________________________ -AliITStrackerSA::AliITStrackerSA(AliITSgeom *geom):AliITStrackerMI(geom) +AliITStrackerSA::AliITStrackerSA(const Char_t *geom):AliITStrackerMI(0), +fPhiEstimate(0), +fITSStandAlone(0), +fLambdac(0), +fPhic(0), +fCoef1(0), +fCoef2(0), +fCoef3(0), +fNloop(0), +fPhiWin(0), +fLambdaWin(0), +fVert(0), +fVertexer(0), +fListOfTracks(0), +fListOfSATracks(0), +fITSclusters(0), +fInwardFlag(0), +fOuterStartLayer(0), +fInnerStartLayer(5), +fMinNPoints(0), +fMinQ(0.), +fCluLayer(0), +fCluCoord(0) { // Standard constructor (Vertex is known and passed to this obj.) + if (geom) { + AliWarning("\"geom\" is actually a dummy argument !"); + } + Init(); fVert = 0; - fGeom = geom; } //____________________________________________________________________________ -AliITStrackerSA::AliITStrackerSA(AliITSgeom *geom, AliESDVertex *vert):AliITStrackerMI(geom) +AliITStrackerSA::AliITStrackerSA(const Char_t *geom, AliESDVertex *vert):AliITStrackerMI(0), +fPhiEstimate(0), +fITSStandAlone(0), +fLambdac(0), +fPhic(0), +fCoef1(0), +fCoef2(0), +fCoef3(0), +fNloop(0), +fPhiWin(0), +fLambdaWin(0), +fVert(vert), +fVertexer(0), +fListOfTracks(0), +fListOfSATracks(0), +fITSclusters(0), +fInwardFlag(0), +fOuterStartLayer(0), +fInnerStartLayer(5), +fMinNPoints(0), +fMinQ(0.), +fCluLayer(0), +fCluCoord(0) { // Standard constructor (Vertex is known and passed to this obj.) + if (geom) { + AliWarning("\"geom\" is actually a dummy argument !"); + } Init(); - fVert = vert; - fGeom = geom; } //____________________________________________________________________________ -AliITStrackerSA::AliITStrackerSA(AliITSgeom *geom, AliITSVertexer *vertexer):AliITStrackerMI(geom) +AliITStrackerSA::AliITStrackerSA(const Char_t *geom, AliITSVertexer *vertexer):AliITStrackerMI(0), +fPhiEstimate(0), +fITSStandAlone(0), +fLambdac(0), +fPhic(0), +fCoef1(0), +fCoef2(0), +fCoef3(0), +fNloop(0), +fPhiWin(0), +fLambdaWin(0), +fVert(), +fVertexer(vertexer), +fListOfTracks(0), +fListOfSATracks(0), +fITSclusters(0), +fInwardFlag(0), +fOuterStartLayer(0), +fInnerStartLayer(5), +fMinNPoints(0), +fMinQ(0.), +fCluLayer(0), +fCluCoord(0) { // Standard constructor (Vertex is unknown - vertexer is passed to this obj) + if (geom) { + AliWarning("\"geom\" is actually a dummy argument !"); + } Init(); fVertexer = vertexer; - fGeom = geom; } //____________________________________________________________________________ -AliITStrackerSA::AliITStrackerSA(const AliITStrackerSA& tracker):AliITStrackerMI(){ +AliITStrackerSA::AliITStrackerSA(const AliITStrackerSA& tracker):AliITStrackerMI(), +fPhiEstimate(tracker.fPhiEstimate), +fITSStandAlone(tracker.fITSStandAlone), +fLambdac(tracker.fLambdac), +fPhic(tracker.fPhic), +fCoef1(tracker.fCoef1), +fCoef2(tracker.fCoef2), +fCoef3(tracker.fCoef3), +fNloop(tracker.fNloop), +fPhiWin(tracker.fPhiWin), +fLambdaWin(tracker.fLambdaWin), +fVert(tracker.fVert), +fVertexer(tracker.fVertexer), +fListOfTracks(tracker.fListOfTracks), +fListOfSATracks(tracker.fListOfSATracks), +fITSclusters(tracker.fITSclusters), +fInwardFlag(tracker.fInwardFlag), +fOuterStartLayer(tracker.fOuterStartLayer), +fInnerStartLayer(tracker.fInnerStartLayer), +fMinNPoints(tracker.fMinNPoints), +fMinQ(tracker.fMinQ), +fCluLayer(tracker.fCluLayer), +fCluCoord(tracker.fCluCoord) { // Copy constructor - fPhiEstimate = tracker.fPhiEstimate; for(Int_t i=0;i<2;i++){ fPoint1[i]=tracker.fPoint1[i]; fPoint2[i]=tracker.fPoint2[i]; fPoint3[i]=tracker.fPoint3[i]; fPointc[i]=tracker.fPointc[i]; } - fLambdac = tracker.fLambdac; - fPhic = tracker.fPhic; - fCoef1 = tracker.fCoef1; - fCoef2 = tracker.fCoef2; - fCoef3 = tracker.fCoef3; - fNloop = tracker.fNloop; - fPhiWin = tracker.fPhiWin; - fLambdaWin = tracker.fLambdaWin; if(tracker.fVertexer && tracker.fVert){ fVert = new AliESDVertex(*tracker.fVert); } else { fVert = tracker.fVert; } - fVertexer = tracker.fVertexer; - fGeom = tracker.fGeom; - fListOfTracks = tracker.fListOfTracks; - for(Int_t i=0;iGetNlayers();i++){ + for(Int_t i=0;i~AliITStrackerSA(); + new(this) AliITStrackerSA(source); + return *this; + } //____________________________________________________________________________ @@ -132,8 +239,11 @@ AliITStrackerSA::~AliITStrackerSA(){ if(fPhiWin)delete []fPhiWin; if(fLambdaWin)delete []fLambdaWin; fListOfTracks->Delete(); + delete fListOfTracks; + fListOfSATracks->Delete(); + delete fListOfSATracks; if(fCluLayer){ - for(Int_t i=0;iGetNlayers();i++){ + for(Int_t i=0;iDelete(); delete fCluLayer[i]; @@ -142,7 +252,7 @@ AliITStrackerSA::~AliITStrackerSA(){ delete [] fCluLayer; } if(fCluCoord){ - for(Int_t i=0;iGetNlayers();i++){ + for(Int_t i=0;iDelete(); delete fCluCoord[i]; @@ -151,7 +261,30 @@ AliITStrackerSA::~AliITStrackerSA(){ delete [] fCluCoord; } - fGeom = 0; +} + +//____________________________________________________________________________ +Int_t AliITStrackerSA::Clusters2Tracks(AliESDEvent *event){ +// This method is used to find and fit the tracks. By default the corresponding +// method in the parent class is invoked. In this way a combined tracking +// TPC+ITS is performed. If the flag fITSStandAlone is true, the tracking +// is done in the ITS only. In the standard reconstruction chain this option +// can be set via AliReconstruction::SetOption("ITS","onlyITS") + Int_t rc=0; + if(!fITSStandAlone){ + rc=AliITStrackerMI::Clusters2Tracks(event); + } + else { + AliDebug(1,"Stand Alone flag set: doing tracking in ITS alone\n"); + } + if(!rc){ + rc=FindTracks(event,kFALSE); + if(AliITSReconstructor::GetRecoParam()->GetSAUseAllClusters()==kTRUE) { + rc=FindTracks(event,kTRUE); + } + } + + return rc; } //____________________________________________________________________________ @@ -168,13 +301,25 @@ void AliITStrackerSA::Init(){ fPointc[1]=0; fVert = 0; fVertexer = 0; - fGeom = 0; - SetWindowSizes(); + Int_t nLoops=AliITSReconstructor::GetRecoParam()->GetNLoopsSA(); + if(nLoops==33){ + SetFixedWindowSizes(); + }else{ + Double_t phimin=AliITSReconstructor::GetRecoParam()->GetMinPhiSA(); + Double_t phimax=AliITSReconstructor::GetRecoParam()->GetMaxPhiSA(); + Double_t lambmin=AliITSReconstructor::GetRecoParam()->GetMinLambdaSA(); + Double_t lambmax=AliITSReconstructor::GetRecoParam()->GetMaxLambdaSA(); + SetCalculatedWindowSizes(nLoops,phimin,phimax,lambmin,lambmax); + } + fMinQ=AliITSReconstructor::GetRecoParam()->GetSAMinClusterCharge(); fITSclusters = 0; - SetSixPoints(); - fListOfTracks=new TObjArray(0,0); + SetOuterStartLayer(1); + SetSAFlag(kFALSE); + fListOfTracks=new TClonesArray("AliITStrackMI",100); + fListOfSATracks=new TClonesArray("AliITStrackSA",100); fCluLayer = 0; fCluCoord = 0; + fMinNPoints = 3; } //_______________________________________________________________________ void AliITStrackerSA::ResetForFinding(){ @@ -188,537 +333,550 @@ void AliITStrackerSA::ResetForFinding(){ fCoef3=0; fPointc[0]=0; fPointc[1]=0; - fListOfTracks->Delete(); + fListOfTracks->Clear(); + fListOfSATracks->Clear(); } //______________________________________________________________________ -Int_t AliITStrackerSA::FindTracks(AliESD* event){ +Int_t AliITStrackerSA::FindTracks(AliESDEvent* event, Bool_t useAllClusters){ // Track finder using the ESD object - - //controllare numero cluster sui layer1 e 2 (morti?) - //non trova tracce...controllare.. + AliDebug(2,Form(" field is %f",event->GetMagneticField())); + AliDebug(2,Form("SKIPPING %d %d %d %d %d %d",ForceSkippingOfLayer(0),ForceSkippingOfLayer(1),ForceSkippingOfLayer(2),ForceSkippingOfLayer(3),ForceSkippingOfLayer(4),ForceSkippingOfLayer(5))); 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; } - - //Reads event and mark clusters of traks already found, with flag kITSin - Int_t nentr=event->GetNumberOfTracks(); - while (nentr--) { - AliESDtrack *track=event->GetTrack(nentr); - if (track->GetStatus()&AliESDtrack::kITSin==AliESDtrack::kITSin){ - UInt_t idx[6]; - Int_t ncl = track->GetITSclusters(idx); - for(Int_t k=0;kSetBit(kSAflag); - } - } - } - - Double_t primaryVertex[3]; - event->GetVertex()->GetXYZ(primaryVertex); - //Creates TClonesArray with clusters for each layer. The clusters already used - //by AliITStrackerMI are not considered - - Int_t nclusters[6]={0,0,0,0,0,0}; - Int_t dmar[6]={0,0,0,0,0,0}; - fCluLayer = new TClonesArray*[fGeom->GetNlayers()]; - fCluCoord = new TClonesArray*[fGeom->GetNlayers()]; - - for(Int_t i=0;iGetNlayers();i++){ - AliITSlayer &layer=fgLayers[i]; - for(Int_t cli=0;cliTestBit(kSAflag)==kTRUE) continue; //clusters used by TPC prol. - if(cls->GetQ()==0) continue; //fake clusters dead zones - nclusters[i]++; - } - dmar[i]=0; - fCluLayer[i] = new TClonesArray("AliITSRecPoint",nclusters[i]); - fCluCoord[i] = new TClonesArray("AliITSclusterTable",nclusters[i]); - } - - - Int_t * firstmod = new Int_t[fGeom->GetNlayers()]; - for(Int_t i=0;iGetNlayers();i++){ - firstmod[i]=fGeom->GetModuleIndex(i+1,1,1); - } - - for(Int_t ilay=0;ilayGetNlayers();ilay++){ - TClonesArray &clulay = *fCluLayer[ilay]; - TClonesArray &clucoo = *fCluCoord[ilay]; - AliITSlayer &layer=fgLayers[ilay]; - for(Int_t cli=0;cliTestBit(kSAflag)==kTRUE) continue; - if(cls->GetQ()==0) continue; - Double_t phi=0;Double_t lambda=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 = cls->GetDetectorIndex()+firstmod[ilay]; - GetCoorAngles(cls,module,phi,lambda,x,y,z,primaryVertex); - GetCoorErrors(cls,module,sx,sy,sz); - new (clulay[dmar[ilay]]) AliITSRecPoint(*cls); - new (clucoo[dmar[ilay]]) AliITSclusterTable(x,y,z,sx,sy,sz,phi,lambda,cli); - dmar[ilay]++; - } - } - - - //Get primary vertex - - Int_t ntrack=0; - //loop on the different windows - for(Int_t nloop=0;nloopGetEntries();ncl++){ //loop starting from layer 0 - - ResetForFinding(); - Int_t pflag=0; - - AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[0]->At(ncl); - - if(!cl) continue; - - - if (cl->GetQ()<=0) continue; - - AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(0,ncl); - fPhic = arr->GetPhi(); - fLambdac = arr->GetLambda(); - if (TMath::Abs(fLambdac)>0.26*TMath::Pi()) continue; - fPhiEstimate = fPhic; - AliITStrackSA* trs = new AliITStrackSA(); - fPoint1[0]=primaryVertex[0]; - fPoint1[1]=primaryVertex[1]; - - - fPoint2[0]=arr->GetX(); - fPoint2[1]=arr->GetY(); - Int_t * nn = new Int_t[fGeom->GetNlayers()];//counter for clusters on each layer - for(Int_t i=0;iGetNlayers();i++){ nn[i]=0;} - nn[0] = SearchClusters(0,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag); - - nn[1] = SearchClusters(1,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag); - if(nn[1]>0){ - pflag=1; - fPoint3[0] = fPointc[0]; - fPoint3[1] = fPointc[1]; + Int_t nentr=event->GetNumberOfTracks(); + if(!useAllClusters) { + while (nentr--) { + AliESDtrack *track=event->GetTrack(nentr); + if ((track->GetStatus()&AliESDtrack::kITSin) == AliESDtrack::kITSin){ + Int_t idx[12]; + Int_t ncl = track->GetITSclusters(idx); + for(Int_t k=0;kSetBit(kSAflag); + } } - nn[2] = SearchClusters(2,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag); - if(nn[1]==0 && nn[2]==0) pflag=0; - if(nn[2]!=0 && nn[1]!=0){ pflag=1; UpdatePoints();} - if(nn[2]!=0 && nn[1]==0){ - pflag=1; - fPoint3[0]=fPointc[0]; - fPoint3[1]=fPointc[1]; + } + }else{ + while (nentr--) { + AliESDtrack *track=event->GetTrack(nentr); + if ((track->GetStatus()&AliESDtrack::kITSin) == AliESDtrack::kITSin){ + Int_t idx[12]; + Int_t ncl = track->GetITSclusters(idx); + for(Int_t k=0;kResetBit(kSAflag); + } } - - nn[3] = SearchClusters(3,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag); - pflag=1; - if(nn[3]!=0) UpdatePoints(); - nn[4] = SearchClusters(4,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag); - pflag=1; - if(nn[4]!=0) UpdatePoints(); - nn[5] = SearchClusters(5,fPhiWin[nloop],fLambdaWin[nloop],trs,primaryVertex[2],pflag); - - - Int_t layOK=0; - Int_t numberofpoints; - if(fSixPoints) numberofpoints=6; //check of the candidate track - else numberofpoints=5; //if track is good (with the required number - for(Int_t nnp=0;nnpGetNlayers();nnp++){ //of points) it is written on file - if(nn[nnp]!=0) layOK+=1; + } + } + //Get primary vertex + Double_t primaryVertex[3]; + event->GetVertex()->GetXYZ(primaryVertex); + //Creates TClonesArray with clusters for each layer. The clusters already used + //by AliITStrackerMI are not considered + Int_t nclusters[AliITSgeomTGeo::kNLayers]={0,0,0,0,0,0}; + Int_t dmar[AliITSgeomTGeo::kNLayers]={0,0,0,0,0,0}; + if (fCluLayer == 0) { + fCluLayer = new TClonesArray*[AliITSgeomTGeo::kNLayers]; + fCluCoord = new TClonesArray*[AliITSgeomTGeo::kNLayers]; + for(Int_t i=0;iTestBit(kSAflag)==kTRUE) continue; //clusters used by TPC prol. + if(cls->GetQ()==0) continue; //fake clusters dead zones + if(i>1 && cls->GetQ()<=fMinQ) continue; // cut on SDD and SSD cluster charge + nclusters[i]++; } - if(layOK>=numberofpoints){ - - AliITStrackV2* tr2 = FitTrack(trs,primaryVertex); - - if(tr2==0) continue; + } + dmar[i]=0; + if(!fCluLayer[i]){ + fCluLayer[i] = new TClonesArray("AliITSRecPoint",nclusters[i]); + }else{ + fCluLayer[i]->Delete(); + fCluLayer[i]->Expand(nclusters[i]); + } + if(!fCluCoord[i]){ + fCluCoord[i] = new TClonesArray("AliITSclusterTable",nclusters[i]); + }else{ + fCluCoord[i]->Delete(); + fCluCoord[i]->Expand(nclusters[i]); + } + } - AliESDtrack outtrack; - outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin); - event->AddTrack(&outtrack); - ntrack++; - + for(Int_t ilay=0;ilayTestBit(kSAflag)==kTRUE) continue; + if(cls->GetQ()==0) continue; + if(ilay>1 && cls->GetQ()<=fMinQ) continue; + Double_t phi=0;Double_t lambda=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; + GetCoorAngles(cls,phi,lambda,x,y,z,primaryVertex); + GetCoorErrors(cls,sx,sy,sz); + new (clulay[dmar[ilay]]) AliITSRecPoint(*cls); + new (clucoo[dmar[ilay]]) AliITSclusterTable(x,y,z,sx,sy,sz,phi,lambda,cli); + dmar[ilay]++; } - + } + } + + // track counter + Int_t ntrack=0; + + static Int_t nClusLay[AliITSgeomTGeo::kNLayers];//counter for clusters on each layer + Int_t startLayForSeed=0; + Int_t lastLayForSeed=fOuterStartLayer; + Int_t nSeedSteps=lastLayForSeed-startLayForSeed; + Int_t seedStep=1; + if(fInwardFlag){ + startLayForSeed=AliITSgeomTGeo::GetNLayers()-1; + lastLayForSeed=fInnerStartLayer; + nSeedSteps=startLayForSeed-lastLayForSeed; + seedStep=-1; + } - delete trs; - delete[] nn; + // loop on minimum number of points + for(Int_t iMinNPoints=AliITSgeomTGeo::GetNLayers(); iMinNPoints>=fMinNPoints; iMinNPoints--) { + + // loop on starting layer for track finding + for(Int_t iSeedLay=0; iSeedLay<=nSeedSteps; iSeedLay++) { + Int_t theLay=startLayForSeed+iSeedLay*seedStep; + if(ForceSkippingOfLayer(theLay)) continue; + Int_t minNPoints=iMinNPoints-theLay; + if(fInwardFlag) minNPoints=iMinNPoints-(AliITSgeomTGeo::GetNLayers()-1-theLay); + for(Int_t i=theLay+1;iGetEntries(); + while(nclTheLay--){ + ResetForFinding(); + Bool_t useRP=SetFirstPoint(theLay,nclTheLay,primaryVertex); + if(!useRP) continue; + AliITStrackSA trs; + + Int_t pflag=0; + Int_t kk; + for(kk=0;kk=0; nnp--){ + if(nClusLay[nnp]!=0) layOK+=1; + } + } + if(layOK>=minNPoints){ + AliDebug(2,Form("---NPOINTS: %d; MAP: %d %d %d %d %d %d\n",layOK,nClusLay[0],nClusLay[1],nClusLay[2],nClusLay[3],nClusLay[4],nClusLay[5])); + AliITStrackV2* tr2 = 0; + tr2 = FitTrack(&trs,primaryVertex); + if(!tr2){ + continue; + } + AliDebug(2,Form("---NPOINTS fit: %d\n",tr2->GetNumberOfClusters())); + + StoreTrack(tr2,event,useAllClusters); + ntrack++; + + } + + }//end loop on clusters of theLay + } //end loop on window sizes + } //end loop on theLay + }//end loop on min points + + // search for 1-point tracks in SPD, only for cosmics + // (A.Dainese 21.03.08) + if(AliITSReconstructor::GetRecoParam()->GetSAOnePointTracks() && + TMath::Abs(event->GetMagneticField())<0.01) { + Int_t outerLayer=1; // only SPD + for(Int_t innLay=0; innLay<=TMath::Min(1,fOuterStartLayer); innLay++) { + // counter for clusters on each layer + + for(Int_t nloop=0;nloopGetEntries(); + while(nclInnLay--){ //loop starting from layer innLay + ResetForFinding(); + Bool_t useRP=SetFirstPoint(innLay,nclInnLay,primaryVertex); + if(!useRP) continue; + AliITStrackSA trs; + + Int_t pflag=0; + Int_t kk; + for(kk=0;kkGetNumberOfClusters())); + + StoreTrack(tr2,event,useAllClusters); + ntrack++; + + } + + }//end loop on clusters of innLay + } //end loop on window sizes - }//end loop on clusters of layer1 - - //end loop2 - } - - //if 5/6 points are required, second loop starting - //from second layer, to find tracks with point of - //layer 1 missing - - if(!fSixPoints){ - // counter for clusters on each layer - Int_t * nn = new Int_t[fGeom->GetNlayers()-1]; - for(Int_t nloop=0;nloopGetEntries(); - while(ncl2--){ //loop starting from layer 2 - ResetForFinding(); - Int_t pflag=0; - AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[1]->At(ncl2); - - if(!cl) continue; - AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(1,ncl2); - fPhic = arr->GetPhi(); - fLambdac = arr->GetLambda(); - fPhiEstimate = fPhic; - - AliITStrackSA* trs = new AliITStrackSA(); - fPoint1[0]=primaryVertex[0]; - fPoint1[1]=primaryVertex[1]; - - fPoint2[0]=arr->GetX(); - fPoint2[1]=arr->GetY(); - for(Int_t kk=0;kkGetNlayers()-1;kk++)nn[kk] = 0; - nn[0] = SearchClusters(1,fPhiWin[nloop],fLambdaWin[nloop], - trs,primaryVertex[2],pflag); - nn[1] = SearchClusters(2,fPhiWin[nloop],fLambdaWin[nloop], - trs,primaryVertex[2],pflag); - if(nn[1]!=0){ - pflag=1; - fPoint3[0]=fPointc[0]; - fPoint3[1]=fPointc[1]; - } - nn[2]= SearchClusters(3,fPhiWin[nloop],fLambdaWin[nloop], - trs,primaryVertex[2],pflag); - if(nn[2]!=0){ - pflag=1; - UpdatePoints(); - } - nn[3]= SearchClusters(4,fPhiWin[nloop],fLambdaWin[nloop], - trs,primaryVertex[2],pflag); - if(nn[3]!=0){ - pflag=1; - UpdatePoints(); - } - nn[4]=SearchClusters(5,fPhiWin[nloop],fLambdaWin[nloop], - trs,primaryVertex[2],pflag); - - Int_t fl=0; - for(Int_t nnp=0;nnpGetNlayers()-1;nnp++){ - if(nn[nnp]!=0) fl+=1; - } - if(fl>=5){ // 5/6 - AliITStrackV2* tr2 = FitTrack(trs,primaryVertex); - if(tr2==0){ - continue; - } - - AliESDtrack outtrack; - outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin); - event->AddTrack(&outtrack); - ntrack++; - - } - - - delete trs; - }//end loop on clusters of layer2 - } - - delete [] nn; - } //end opt="5/6" - - delete [] firstmod; - Info("FindTracks","Number of found tracks: %d",event->GetNumberOfTracks()); + } //end loop on innLay + } // end search 1-point tracks + + if(!useAllClusters) AliInfo(Form("Number of found tracks: %d",event->GetNumberOfTracks())); + ResetForFinding(); return 0; } - - - - //________________________________________________________________________ -AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex){ - //fit of the found track +AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVertex,Bool_t onePoint) { + //fit of the found track (most general case, also <6 points, layers missing) + // A.Dainese 16.11.07 - Int_t * firstmod = new Int_t[fGeom->GetNlayers()]; - for(Int_t i=0;iGetNlayers();i++){ - firstmod[i]=fGeom->GetModuleIndex(i+1,1,1); - } + const Int_t kMaxClu=AliITStrackSA::kMaxNumberOfClusters; - Int_t nclusters = tr->GetNumberOfClustersSA(); - TObjArray** listlayer = new TObjArray*[fGeom->GetNlayers()]; - for(Int_t i=0;iGetNlayers();i++){ - listlayer[i] = new TObjArray(0,0); + static Int_t firstmod[AliITSgeomTGeo::kNLayers]; + + static Int_t clind[AliITSgeomTGeo::kNLayers][kMaxClu]; + static Int_t clmark[AliITSgeomTGeo::kNLayers][kMaxClu]; + static Int_t end[AliITSgeomTGeo::kNLayers]; + static AliITSRecPoint *listlayer[AliITSgeomTGeo::kNLayers][kMaxClu]; + + for(Int_t i=0;iGetNlayers()]; - Int_t * kkk = new Int_t[fGeom->GetNlayers()]; - for(Int_t i=0;iGetNlayers();i++) {nnn[i]=0;kkk[i]=0;} + + Int_t nclusters = tr->GetNumberOfClustersSA(); for(Int_t ncl=0;nclGetClusterIndexSA(ncl); AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(index); if(cl->TestBit(kSAflag)==kTRUE) cl->ResetBit(kSAflag); Int_t lay = (index & 0xf0000000) >> 28; - if(lay==0) { listlayer[0]->AddLast(cl); clind0[nnn[0]]=index;nnn[0]++;} - if(lay==1) { listlayer[1]->AddLast(cl); clind1[nnn[1]]=index;nnn[1]++;} - if(lay==2) { listlayer[2]->AddLast(cl); clind2[nnn[2]]=index;nnn[2]++;} - if(lay==3) { listlayer[3]->AddLast(cl); clind3[nnn[3]]=index;nnn[3]++;} - if(lay==4) { listlayer[4]->AddLast(cl); clind4[nnn[4]]=index;nnn[4]++;} - if(lay==5) { listlayer[5]->AddLast(cl); clind5[nnn[5]]=index;nnn[5]++;} + Int_t nInLay=end[lay]; + listlayer[lay][nInLay]=cl; + clind[lay][nInLay]=index; + end[lay]++; } - delete [] nnn; - for(Int_t nlay=0;nlayGetNlayers();nlay++){ + for(Int_t nlay=0;nlayGetNumberOfMarked(nlay);ncl++){ Int_t mark = tr->GetClusterMark(nlay,ncl); - if(nlay==0) { mark0[kkk[0]]=mark;kkk[0]++;} - if(nlay==1) { mark1[kkk[1]]=mark;kkk[1]++;} - if(nlay==2) { mark2[kkk[2]]=mark;kkk[2]++;} - if(nlay==3) { mark3[kkk[3]]=mark;kkk[3]++;} - if(nlay==4) { mark4[kkk[4]]=mark;kkk[4]++;} - if(nlay==5) { mark5[kkk[5]]=mark;kkk[5]++;} - + clmark[nlay][ncl]=mark; } } - delete [] kkk; - - Int_t * end = new Int_t[fGeom->GetNlayers()]; - for(Int_t i=0;iGetNlayers();i++){ - if(listlayer[i]->GetEntries()==0) end[i]=1; - else end[i]=listlayer[i]->GetEntries(); + Int_t firstLay=-1,secondLay=-1; + for(Int_t i=0;iAt(l1); - Double_t x1,y1,z1,sx1,sy1,sz1; - Double_t x2,y2,z2,sx2,sy2,sz2; - AliITSRecPoint* p1=0; - AliITSRecPoint* p2=0; - Int_t index1=clind0[l1]; - Int_t index2=0; - Int_t mrk1 = mark0[l1]; - Int_t mrk2 = 0; - Int_t lay1=0; - Int_t lay2=1; - Int_t module1=-1; - for(Int_t l2=0;l2At(l2); - index2=clind1[l2]; - mrk2 = mark1[l2]; - for(Int_t l3=0;l3At(l3); - - if(cl0==0 && cl1!=0) { - p2 = cl2;index1=clind2[l3];mrk1=mark2[l3];lay1=2; - p1=cl1; - module1 = p1->GetDetectorIndex()+firstmod[1]; - } - if(cl0!=0 && cl1==0){ - p1=cl0; - p2=cl2;index2=clind2[l3];mrk2=mark2[l3];lay2=2; - module1 = p1->GetDetectorIndex()+firstmod[0]; - } - if(cl0!=0 && cl1!=0){ - p1=cl0; - p2=cl1; - module1 = p1->GetDetectorIndex()+firstmod[0]; - } - - Int_t cln1=mrk1; - Int_t cln2=mrk2; - AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(lay1,cln1); - AliITSclusterTable* arr1= (AliITSclusterTable*)GetClusterCoord(lay2,cln2); - x1 = arr->GetX(); - x2 = arr1->GetX(); - y1 = arr->GetY(); - y2 = arr1->GetY(); - z1 = arr->GetZ(); - z2 = arr1->GetZ(); - sx1 = arr->GetSx(); - sx2 = arr1->GetSx(); - sy1 = arr->GetSy(); - sy2 = arr1->GetSy(); - sz1 = arr->GetSz(); - sz2 = arr1->GetSz(); - - Int_t layer,ladder,detector; - fGeom->GetModuleId(module1,layer,ladder,detector); - Float_t yclu1 = p1->GetY(); - Float_t zclu1 = p1->GetZ(); - Double_t cv=Curvature(primaryVertex[0],primaryVertex[1],x1,y1,x2,y2); - - Double_t tgl2 = (z2-z1)/TMath::Sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); - Double_t phi2 = TMath::ATan2((y2-y1),(x2-x1)); - - for(Int_t l4=0;l4At(l4); - for(Int_t l5=0;l5At(l5); - for(Int_t l6=0;l6At(l6); - AliITStrackSA* trac = new AliITStrackSA(fGeom,layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1); - + if(firstLay==-1 || (secondLay==-1 && !onePoint)) return 0; + TClonesArray &arrMI= *fListOfTracks; + TClonesArray &arrSA= *fListOfSATracks; + Int_t nFoundTracks=0; + + for(Int_t l0=0;l0GetDetectorIndex()+firstmod[firstLay]; + Int_t layer,ladder,detector; + AliITSgeomTGeo::GetModuleId(module1,layer,ladder,detector); + Float_t yclu1 = p1->GetY(); + Float_t zclu1 = p1->GetZ(); + Double_t cv=0,tgl2=0,phi2=0; + + Int_t cln1=mrk1; + AliITSclusterTable* arr1 = (AliITSclusterTable*)GetClusterCoord(firstLay,cln1); + x1 = arr1->GetX(); + y1 = arr1->GetY(); + z1 = arr1->GetZ(); + sx1 = arr1->GetSx(); + sy1 = arr1->GetSy(); + sz1 = arr1->GetSz(); + + if(secondLay>0) { + Int_t cln2=mrk2; + AliITSclusterTable* arr2 = (AliITSclusterTable*)GetClusterCoord(secondLay,cln2); + x2 = arr2->GetX(); + y2 = arr2->GetY(); + z2 = arr2->GetZ(); + sx2 = arr2->GetSx(); + sy2 = arr2->GetSy(); + sz2 = arr2->GetSz(); + cv = Curvature(primaryVertex[0],primaryVertex[1],x1,y1,x2,y2); + tgl2 = (z2-z1)/TMath::Sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); + phi2 = TMath::ATan2((y2-y1),(x2-x1)); + } else { // special case of 1-point tracks, only for cosmics (B=0) + x2 = primaryVertex[0]; + y2 = primaryVertex[1]; + z2 = primaryVertex[2]; + cv = 0; + tgl2 = (z1-z2)/TMath::Sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)); + phi2 = TMath::ATan2((y1-y2),(x1-x2)); + } + + + AliITStrackSA trac(layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1); + + if(cl5!=0) { - trac->AddClusterV2(5,(clind5[l6] & 0x0fffffff)>>0); - trac->AddClusterMark(5,mark5[l6]); + trac.AddClusterV2(5,(clind[5][l5] & 0x0fffffff)>>0); + trac.AddClusterMark(5,clmark[5][l5]); } if(cl4!=0){ - trac->AddClusterV2(4,(clind4[l5] & 0x0fffffff)>>0); - trac->AddClusterMark(4,mark4[l5]); + trac.AddClusterV2(4,(clind[4][l4] & 0x0fffffff)>>0); + trac.AddClusterMark(4,clmark[4][l4]); } if(cl3!=0){ - trac->AddClusterV2(3,(clind3[l4] & 0x0fffffff)>>0); - trac->AddClusterMark(3,mark3[l4]); + trac.AddClusterV2(3,(clind[3][l3] & 0x0fffffff)>>0); + trac.AddClusterMark(3,clmark[3][l3]); } if(cl2!=0){ - trac->AddClusterV2(2,(clind2[l3] & 0x0fffffff)>>0); - trac->AddClusterMark(2,mark2[l3]); + trac.AddClusterV2(2,(clind[2][l2] & 0x0fffffff)>>0); + trac.AddClusterMark(2,clmark[2][l2]); } if(cl1!=0){ - trac->AddClusterV2(1,(clind1[l2] & 0x0fffffff)>>0); - trac->AddClusterMark(1,mark1[l2]); + trac.AddClusterV2(1,(clind[1][l1] & 0x0fffffff)>>0); + trac.AddClusterMark(1,clmark[1][l1]); } if(cl0!=0){ - trac->AddClusterV2(0,(clind0[l1] & 0x0fffffff)>>0); - trac->AddClusterMark(0,mark0[l1]); + trac.AddClusterV2(0,(clind[0][l0] & 0x0fffffff)>>0); + trac.AddClusterMark(0,clmark[0][l0]); } + //fit with Kalman filter using AliITStrackerMI::RefitAt() - + AliITStrackSA ot(trac); - AliITStrackMI* ot = new AliITStrackSA(*trac); - - ot->ResetCovariance(); - ot->ResetClusters(); + ot.ResetCovariance(10.); + ot.ResetClusters(); - if(RefitAt(49.,ot,trac)){ //fit from layer 1 to layer 6 - AliITStrackMI *otrack2 = new AliITStrackMI(*ot); - otrack2->ResetCovariance(); - otrack2->ResetClusters(); - //fit from layer 6 to layer 1 - if(RefitAt(3.7,otrack2,ot)) { - fListOfTracks->AddLast(otrack2); - new (tri[nlist]) AliITStrackSA(*trac); - nlist++; - } else { - delete otrack2; - } + // Propagate inside the innermost layer with a cluster + if(ot.Propagate(ot.GetX()-0.1*ot.GetX())) { + + if(RefitAt(AliITSRecoParam::GetrInsideITSscreen(),&ot,&trac)){ //fit from layer 1 to layer 6 + AliITStrackMI otrack2(ot); + otrack2.ResetCovariance(10.); + otrack2.ResetClusters(); + //fit from layer 6 to layer 1 + if(RefitAt(AliITSRecoParam::GetrInsideSPD1(),&otrack2,&ot)) { + new(arrMI[nFoundTracks]) AliITStrackMI(otrack2); + new(arrSA[nFoundTracks]) AliITStrackSA(trac); + ++nFoundTracks; + } - } - - delete ot; - delete trac; + } + } }//end loop layer 6 }//end loop layer 5 - }//end loop layer 4 - + }//end loop layer 4 }//end loop layer 3 }//end loop layer 2 }//end loop layer 1 - delete [] end; - - Int_t dim=fListOfTracks->GetEntries(); - if(dim==0){ - for(Int_t i=0;iGetNlayers();i++){ - delete listlayer[i]; - } - delete [] listlayer; - listSA->Delete(); - delete listSA; - delete [] firstmod; - return 0; - } - Int_t lowchi2 = FindTrackLowChiSquare(fListOfTracks,dim); + if(fListOfTracks->GetEntries()==0) return 0; + + Int_t lowchi2 = FindTrackLowChiSquare(); AliITStrackV2* otrack =(AliITStrackV2*)fListOfTracks->At(lowchi2); - AliITStrackSA* trsa = (AliITStrackSA*)listSA->At(lowchi2); + AliITStrackSA* trsa = (AliITStrackSA*)fListOfSATracks->At(lowchi2); - if(otrack==0) { - for(Int_t i=0;iGetNlayers();i++){ - delete listlayer[i]; - } - delete [] listlayer; - listSA->Delete(); - delete listSA; - delete [] firstmod; - return 0; - } - Int_t * indexc = new Int_t[fGeom->GetNlayers()]; - for(Int_t i=0;iGetNlayers();i++) indexc[i]=0; + if(otrack==0) return 0; + + Int_t indexc[AliITSgeomTGeo::kNLayers]; + for(Int_t i=0;iGetNumberOfClusters();nind++){ indexc[nind] = otrack->GetClusterIndex(nind); } - AliITSRecPoint* cl0 = (AliITSRecPoint*)GetCluster(indexc[0]); - AliITSRecPoint* cl1 = (AliITSRecPoint*)GetCluster(indexc[1]); - AliITSRecPoint* cl2 = (AliITSRecPoint*)GetCluster(indexc[2]); - AliITSRecPoint* cl3 = (AliITSRecPoint*)GetCluster(indexc[3]); - AliITSRecPoint* cl4 = (AliITSRecPoint*)GetCluster(indexc[4]); - Int_t labl[3]={-1,-1,-1}; - if(otrack->GetNumberOfClusters()==fGeom->GetNlayers()){ - AliITSRecPoint* cl5 = (AliITSRecPoint*)GetCluster(indexc[5]); - labl[0]=cl5->GetLabel(0); - labl[1]=cl5->GetLabel(1); - labl[2]=cl5->GetLabel(2); - } - delete [] indexc; - if(otrack->GetNumberOfClusters()==(fGeom->GetNlayers()-1)){ - labl[0]=-1; - labl[1]=-1; - labl[2]=-1; + Int_t labl[6][3]; + for(Int_t i=0;iGetNumberOfClusters()) { + AliITSRecPoint* cl = (AliITSRecPoint*)GetCluster(indexc[i]); + labl[i][0]=cl->GetLabel(0); + labl[i][1]=cl->GetLabel(1); + labl[i][2]=cl->GetLabel(2); + } else { + labl[i][0]=-1; + labl[i][1]=-1; + labl[i][2]=-1; + } } - Int_t numberofpoints; - if(fSixPoints) numberofpoints=6; - else numberofpoints=5; + CookLabel(otrack,0.); //MI change - to see fake ratio - Int_t label = Label(cl0->GetLabel(0),cl1->GetLabel(0), - cl2->GetLabel(0),cl3->GetLabel(0), - cl4->GetLabel(0),labl[0], - cl0->GetLabel(1),cl1->GetLabel(1), - cl2->GetLabel(1),cl3->GetLabel(1), - cl4->GetLabel(1),labl[1], - cl0->GetLabel(2),cl1->GetLabel(2), - cl2->GetLabel(2),cl3->GetLabel(2), - cl4->GetLabel(2),labl[2],numberofpoints); + + Int_t label=FindLabel(labl[0][0],labl[1][0],labl[2][0],labl[3][0],labl[4][0],labl[5][0]); + Int_t lflag=0; + for(Int_t i=0;iGetNumberOfClusters();i++) + if(labl[i][0]==label || labl[i][1]==label || labl[i][2]==label) lflag++; + if(lflagGetNumberOfClusters()) label = -label; otrack->SetLabel(label); - //remove clusters of found track - for(Int_t nlay=0;nlayGetNlayers();nlay++){ + //remove clusters of found track + for(Int_t nlay=0;nlayGetNumberOfMarked(nlay);cln++){ Int_t index = trsa->GetClusterMark(nlay,cln); fCluLayer[nlay]->RemoveAt(index); @@ -726,33 +884,48 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert fCluLayer[nlay]->Compress(); } } - listSA->Delete(); - delete listSA; - for(Int_t i=0;iGetNlayers();i++){ - delete listlayer[i]; - } - delete [] listlayer; - delete [] firstmod; return otrack; } +//_______________________________________________________ +void AliITStrackerSA::StoreTrack(AliITStrackV2 *t,AliESDEvent *event, Bool_t pureSA) const +{ + // + // Add new track to the ESD + // + AliESDtrack outtrack; + outtrack.UpdateTrackParams(t,AliESDtrack::kITSin); + if(pureSA) outtrack.SetStatus(AliESDtrack::kITSpureSA); + for(Int_t i=0;i<12;i++) { + outtrack.SetITSModuleIndex(i,t->GetModuleIndex(i)); + } + Double_t sdedx[4]={0.,0.,0.,0.}; + for(Int_t i=0; i<4; i++) sdedx[i]=t->GetSampledEdx(i); + outtrack.SetITSdEdxSamples(sdedx); + event->AddTrack(&outtrack); + + return; +} //_______________________________________________________ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t lambdawindow, AliITStrackSA* trs,Double_t /*zvertex*/,Int_t pflag){ //function used to to find the clusters associated to the track + + if(ForceSkippingOfLayer(layer)) return 0; + Int_t nc=0; AliITSlayer &lay = fgLayers[layer]; Double_t r=lay.GetR(); - if(pflag==1){ + if(pflag==1){ Float_t cx1,cx2,cy1,cy2; FindEquation(fPoint1[0],fPoint1[1],fPoint2[0],fPoint2[1],fPoint3[0],fPoint3[1],fCoef1,fCoef2,fCoef3); if (FindIntersection(fCoef1,fCoef2,fCoef3,-r*r,cx1,cy1,cx2,cy2)==0) return 0; - Double_t fi1=TMath::ATan2(cy1,cx1); - Double_t fi2=TMath::ATan2(cy2,cx2); + Double_t fi1=TMath::ATan2(cy1-fPoint1[1],cx1-fPoint1[0]); + Double_t fi2=TMath::ATan2(cy2-fPoint1[1],cx2-fPoint1[0]); fPhiEstimate=ChoosePoint(fi1,fi2,fPhic); } @@ -762,6 +935,7 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la AliITSRecPoint *c = (AliITSRecPoint*)fCluLayer[layer]->At(index); if (!c) continue; if (c->GetQ()<=0) continue; + if(layer>1 && c->GetQ()<=fMinQ) continue; AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(layer,index); Double_t phi = arr->GetPhi(); @@ -787,6 +961,26 @@ Int_t AliITStrackerSA::SearchClusters(Int_t layer,Double_t phiwindow,Double_t la return nc; } +//________________________________________________________________ +Bool_t AliITStrackerSA::SetFirstPoint(Int_t lay, Int_t clu, Double_t* primaryVertex){ + // Sets the first point (seed) for tracking + + AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[lay]->At(clu); + if(!cl) return kFALSE; + if (cl->GetQ()<=0) return kFALSE; + if(lay>1 && cl->GetQ()<=fMinQ) return kFALSE; + + AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(lay,clu); + fPhic = arr->GetPhi(); + fLambdac = arr->GetLambda(); + fPhiEstimate = fPhic; + fPoint1[0]=primaryVertex[0]; + fPoint1[1]=primaryVertex[1]; + fPoint2[0]=arr->GetX(); + fPoint2[1]=arr->GetY(); + return kTRUE; +} + //________________________________________________________________ void AliITStrackerSA::UpdatePoints(){ //update of points for the estimation of the curvature @@ -875,54 +1069,35 @@ Double_t AliITStrackerSA::ChoosePoint(Double_t p1, Double_t p2, Double_t pp){ //_________________________________________________________________ -Int_t AliITStrackerSA::FindTrackLowChiSquare(TObjArray* tracklist, Int_t dim) const { - // returns track with lowes chi square - if(dim==1){ - //AliITStrackV2* trk = (AliITStrackV2*)tracklist->At(0); - //return trk; - return 0; - } - //if(dim==0) return 0; - Double_t * chi2 = new Double_t[dim]; - Int_t * index = new Int_t[dim]; - for(Int_t i=0;iAt(i); - chi2[i]=trk->GetChi2(); - index[i]=i; - } - - Int_t w=0;Double_t value; - Int_t lp; - while(wGetEntries(); + if(dim<=1) return 0; + AliITStrackV2* trk = (AliITStrackV2*)fListOfTracks->At(0); + Double_t minChi2=trk->GetChi2(); + Int_t index=0; + for(Int_t i=1;iAt(i); + Double_t chi2=trk->GetChi2(); + if(chi2=0;i--) if(lb[i]==-1) num=i; while(k=numberofpoints) return ll; + if(lflag>=minNPoints) return ll; else return -ll; } - //_____________________________________________________________________________ -void AliITStrackerSA::SetWindowSizes(Int_t n, Double_t *phi, Double_t *lam){ +void AliITStrackerSA::SetCalculatedWindowSizes(Int_t n, Float_t phimin, Float_t phimax, Float_t lambdamin, Float_t lambdamax){ + // Set sizes of the phi and lambda windows used for track finding + fNloop = n; + if(fPhiWin) delete [] fPhiWin; + if(fLambdaWin) delete [] fLambdaWin; + fPhiWin = new Double_t[fNloop]; + fLambdaWin = new Double_t[fNloop]; + Float_t stepPhi=(phimax-phimin)/(Float_t)(fNloop-1); + Float_t stepLambda=(lambdamax-lambdamin)/(Float_t)(fNloop-1); + for(Int_t k=0;kGetFactorSAWindowSizes(); // possibility to enlarge windows for cosmics reco with large misalignments (A.Dainese) + for(Int_t k=0;kGetRotMatrix(module,rot); Int_t lay,lad,det; fGeom->GetModuleId(module,lay,lad,det); Float_t tx,ty,tz; fGeom->GetTrans(lay,lad,det,tx,ty,tz); @@ -1035,30 +1229,44 @@ void AliITStrackerSA::GetCoorAngles(AliITSRecPoint* cl,Int_t module,Double_t &ph Float_t cp=TMath::Cos(phi1), sp=TMath::Sin(phi1); Float_t r=tx*cp+ty*sp; - x= r*cp - cl->GetY()*sp; + xyz= r*cp - cl->GetY()*sp; y= r*sp + cl->GetY()*cp; z=cl->GetZ(); - - phi=TMath::ATan2(y,x); +*/ + Float_t xyz[3]; + cl->GetGlobalXYZ(xyz); + x=xyz[0]; + y=xyz[1]; + z=xyz[2]; + + phi=TMath::ATan2(y-vertex[1],x-vertex[0]); lambda=TMath::ATan2(z-vertex[2],TMath::Sqrt((x-vertex[0])*(x-vertex[0])+(y-vertex[1])*(y-vertex[1]))); } //________________________________________________________________________ -void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl, Int_t module,Float_t &sx,Float_t &sy, Float_t &sz){ - - //returns x,y,z of cluster in global coordinates +void AliITStrackerSA::GetCoorErrors(AliITSRecPoint* cl,Float_t &sx,Float_t &sy, Float_t &sz){ + //returns sigmax, y, z of cluster in global coordinates +/* Double_t rot[9]; fGeom->GetRotMatrix(module,rot); - Int_t lay,lad,det; fGeom->GetModuleId(module,lay,lad,det); + Int_t lay,lad,det; + AliITSgeomTGeo::GetModuleId(module,lay,lad,det); Double_t alpha=TMath::ATan2(rot[1],rot[0])+TMath::Pi(); Double_t phi=TMath::Pi()/2+alpha; if (lay==1) phi+=TMath::Pi(); Float_t cp=TMath::Cos(phi), sp=TMath::Sin(phi); - +*/ + Float_t covm[6]; + cl->GetGlobalCov(covm); + sx=TMath::Sqrt(covm[0]); + sy=TMath::Sqrt(covm[3]); + sz=TMath::Sqrt(covm[5]); +/* sx = TMath::Sqrt(sp*sp*cl->GetSigmaY2()); sy = TMath::Sqrt(cp*cp*cl->GetSigmaY2()); sz = TMath::Sqrt(cl->GetSigmaZ2()); - +*/ } +