From b8ed1a9251eec86ea9e920d0f23ae8236f51f704 Mon Sep 17 00:00:00 2001 From: hristov Date: Fri, 3 Aug 2007 07:39:48 +0000 Subject: [PATCH] * Possibility to reconstruct cosmic muon tracks that cross the ITS at a distance from the origin smaller than the radius of the inner SSD layer: expected to be useful for ITS alignment. (before we reconstructed only muons crossing the inner SPD layer) Modified classes: -AliITSVertexerCosmics: it now builds the "fake" vertex using any layer (SetSAFlag(kTRUE); if(sat->GetSAFlag())AliDebug(1,"Tracking Performed in ITS only\n"); + if(selectedTracker.Contains("cosmics")||selectedTracker.Contains("COSMICS")) + sat->SetOuterStartLayer(AliITSgeomTGeo::GetNLayers()-2); } TString selectedPIDmethod = GetOption(); diff --git a/ITS/AliITSVertexerCosmics.cxx b/ITS/AliITSVertexerCosmics.cxx index efdb9872eb2..e393c550bb6 100644 --- a/ITS/AliITSVertexerCosmics.cxx +++ b/ITS/AliITSVertexerCosmics.cxx @@ -25,25 +25,26 @@ //------------------------------------------------------------------------ // This class implements a method to construct a "fake" primary -// vertex for cosmic events in which the muon crosses the SPD inner -// layer (SPD1). A fake primary vertex is needed for the reconstruction, +// vertex for cosmic events in which the muon crosses one of 5 inner +// ITS layers. A fake primary vertex is needed for the reconstruction, // with e.g. AliITStrackerSA, of the two tracks produced by the muon // in the ITS. -// We build pairs of clusters on SPD1 and define the fake vertex as +// We build pairs of clusters on a given layer and define the fake vertex as // the mid-point of the straight line joining the two clusters. -// We reject the backgroung by requiring at least one clusters on SPD2 -// closer than fMaxDistOnSPD2 to the tracklet prolongation. +// We use the innermost layer that has at least two clusters. +// We reject the background by requiring at least one cluster on the outer +// layer, closer than fMaxDistOnOuterLayer to the tracklet prolongation. // We can reject (potentially pathological) events with the muon track -// tangential to the SPD1 layer by the requiring the radial position of +// tangential to the layer by the requiring the radial position of // the vertex to be smaller than fMaxVtxRadius. // Due to background clusters, more than one vertex per event can // be found. We consider the first found. +// The errors on x,y,z of the vertex are calculated as errors on the mean +// of clusters coordinates. Non-diag elements of vertex cov. mat. are set to 0. // The number of contributors set in the AliESDVertex object is the -// number of vertices found in the event; if this number is <1, +// number of the layer on which the tracklet was built; if this number is -1, // the procedure could not find a vertex position and by default // the vertex coordinates are set to (0,0,0) with large errors (100,100,100) -// Number of contributors = 0 --> No SPD1 tracklets matching criteria -// Number of contributors = -1 --> No SPD1 recpoints // // Origin: A.Dainese, andrea.dainese@lnl.infn.it //------------------------------------------------------------------------- @@ -52,19 +53,23 @@ ClassImp(AliITSVertexerCosmics) //------------------------------------------------------------------------- AliITSVertexerCosmics::AliITSVertexerCosmics():AliITSVertexer(), -fFirstSPD1(0), -fLastSPD1(0), -fFirstSPD2(0), -fLastSPD2(0), -fMaxDistOnSPD2(0), -fMaxVtxRadius(0), +fMaxDistOnOuterLayer(0), fMinDist2Vtxs(0) { // Default constructor - SetSPD1Modules(); - SetSPD2Modules(); - SetMaxDistOnSPD2(); - SetMaxVtxRadius(); + SetFirstLastModules(0,0,79); + SetFirstLastModules(1,80,239); + SetFirstLastModules(2,240,323); + SetFirstLastModules(3,324,499); + SetFirstLastModules(4,500,1247); + SetFirstLastModules(5,1248,2197); + SetMaxVtxRadius(0,3.5); + SetMaxVtxRadius(1,6.5); + SetMaxVtxRadius(2,14.5); + SetMaxVtxRadius(3,23.5); + SetMaxVtxRadius(4,37.5); + SetMaxVtxRadius(5,42.5); + SetMaxDistOnOuterLayer(); SetMinDist2Vtxs(); } //-------------------------------------------------------------------------- @@ -83,76 +88,106 @@ AliESDVertex* AliITSVertexerCosmics::FindVertexForCurrentEvent(Int_t evnumber) TClonesArray *recpoints=new TClonesArray("AliITSRecPoint",10000); rpTree->SetBranchAddress("ITSRecPoints",&recpoints); - Double_t xclspd1[100],yclspd1[100],zclspd1[100],modclspd1[100]; - Int_t nclspd1stored=0; - Double_t xclspd2[100],yclspd2[100],zclspd2[100],modclspd2[100]; - Int_t nclspd2stored=0; - Int_t nrecpoints,nrecpointsSPD1=0; - - Double_t gc[3]={0.,0.,0.}; - Double_t lc[3]={0.,0.,0.}; Int_t lay,lad,det; - Double_t x[100],y[100],z[100],p1[3],p2[3],p3[3]; + // Search for innermost layer with at least two clusters + // on two different modules + Int_t ilayer=0; + while(ilayer<6) { + Int_t nHitModules=0; + for(Int_t imodule=fFirst[ilayer]; imodule<=fLast[ilayer]; imodule++) { + rpTree->GetEvent(imodule); + AliITSgeomTGeo::GetModuleId(imodule,lay,lad,det); + lay -= 1; // AliITSgeomTGeo gives layer from 1 to 6, we want 0 to 5 + if(lay!=ilayer) AliFatal("Layer mismatch!"); + if(recpoints->GetEntriesFast()>0) nHitModules++; + } + if(nHitModules>=2) break; + ilayer++; + } + printf("Building tracklets on layer %d\n",ilayer); + + + Float_t xclInnLay[100],yclInnLay[100],zclInnLay[100],modclInnLay[100]; + Float_t e2xclInnLay[100],e2yclInnLay[100],e2zclInnLay[100]; + Int_t nclInnLayStored=0; + Float_t xclOutLay[100],yclOutLay[100],zclOutLay[100],modclOutLay[100]; + Int_t nclOutLayStored=0; + Int_t nRecPoints,nRecPointsInnLay=0; + + Float_t gc[3],gcov[5]; + + Float_t x[100],y[100],z[100],e2x[100],e2y[100],e2z[100]; + Double_t p1[3],p2[3],p3[3]; Int_t nvtxs; - Bool_t good,matchtospd2; - Double_t xvtx,yvtx,zvtx,rvtx; + Bool_t good,matchtoOutLay; + Float_t xvtx,yvtx,zvtx,rvtx; - for(Int_t imodule=fFirstSPD1; imoduleGetEvent(imodule); AliITSgeomTGeo::GetModuleId(imodule,lay,lad,det); - nrecpoints=recpoints->GetEntriesFast(); - if(imoduleGetEntriesFast(); + if(imodule<=fLast[ilayer]) nRecPointsInnLay += nRecPoints; + //printf("cosmics: module %d clusters %d\n",imodule,nRecPoints); + for(Int_t irp=0; irpUncheckedAt(irp); // Local coordinates of this recpoint - lc[0]=rp->GetDetLocalX(); - lc[2]=rp->GetDetLocalZ(); - AliITSgeomTGeo::LocalToGlobal(imodule,lc,gc); // global coordinates - if(lay==1) { // store SPD1 clusters - xclspd1[nclspd1stored]=gc[0]; - yclspd1[nclspd1stored]=gc[1]; - zclspd1[nclspd1stored]=gc[2]; - modclspd1[nclspd1stored]=imodule; - nclspd1stored++; + rp->GetGlobalXYZ(gc); + if(lay==ilayer) { // store InnLay clusters + xclInnLay[nclInnLayStored]=gc[0]; + yclInnLay[nclInnLayStored]=gc[1]; + zclInnLay[nclInnLayStored]=gc[2]; + rp->GetGlobalCov(gcov); + e2xclInnLay[nclInnLayStored]=gcov[0]; + e2yclInnLay[nclInnLayStored]=gcov[3]; + e2zclInnLay[nclInnLayStored]=gcov[5]; + modclInnLay[nclInnLayStored]=imodule; + nclInnLayStored++; } - if(lay==2) { // store SPD2 clusters - xclspd2[nclspd2stored]=gc[0]; - yclspd2[nclspd2stored]=gc[1]; - zclspd2[nclspd2stored]=gc[2]; - modclspd2[nclspd2stored]=imodule; - nclspd2stored++; + if(lay==ilayer+1) { // store OutLay clusters + xclOutLay[nclOutLayStored]=gc[0]; + yclOutLay[nclOutLayStored]=gc[1]; + zclOutLay[nclOutLayStored]=gc[2]; + modclOutLay[nclOutLayStored]=imodule; + nclOutLayStored++; } - if(nclspd1stored>100 || nclspd2stored>100) - AliFatal("More than 100 clusters per layer in SPD"); + if(nclInnLayStored>100 || nclOutLayStored>100) + AliFatal("More than 100 clusters per layer"); }// end clusters in a module - }// end SPD modules for a given event + }// end modules // build fake vertices nvtxs=0; - // SPD1 - first cluster - for(Int_t i1spd1=0; i1spd1fMaxVtxRadius) continue; + if(rvtx>fMaxVtxRadius[ilayer]) continue; good = kTRUE; for(Int_t iv=0; ivSetNContributors(nvtxs); + if(nvtxs) { + fCurrentVertex->SetNContributors(ilayer); + } else { + fCurrentVertex->SetNContributors(-1); + } fCurrentVertex->SetTitle("cosmics fake vertex"); - //if(nvtxs>0) fCurrentVertex->Print(); + if(nvtxs>=0) fCurrentVertex->Print(); delete recpoints; itsLoader->UnloadRecPoints(); @@ -213,11 +254,9 @@ void AliITSVertexerCosmics::PrintStatus() const { // Print current status printf("=======================================================\n"); - printf(" fMaxDistOnSPD2: %f\n",fMaxDistOnSPD2); - printf(" fMaxVtxRadius: %f\n",fMaxVtxRadius); + printf(" fMaxDistOnOuterLayer: %f\n",fMaxDistOnOuterLayer); + printf(" fMaxVtxRadius[0]: %f\n",fMaxVtxRadius[0]); printf(" fMinDist2Vtxs: %f\n",fMinDist2Vtxs); - printf(" First layer first and last modules: %d, %d\n",fFirstSPD1,fLastSPD1); - printf(" Second layer first and last modules: %d, %d\n",fFirstSPD2,fLastSPD2); printf("=======================================================\n"); } //------------------------------------------------------------------------- diff --git a/ITS/AliITSVertexerCosmics.h b/ITS/AliITSVertexerCosmics.h index 3136eaaf719..f1686e5b592 100644 --- a/ITS/AliITSVertexerCosmics.h +++ b/ITS/AliITSVertexerCosmics.h @@ -3,7 +3,6 @@ /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. * * See cxx source for full Copyright notice */ -//#include "AliESDVertex.h" #include "AliITSVertexer.h" //----------------------------------------------------------------------- @@ -24,26 +23,24 @@ class AliITSVertexerCosmics : public AliITSVertexer { AliESDVertex* FindVertexForCurrentEvent(Int_t evnumb); void FindVertices(); void PrintStatus() const; - void SetSPD1Modules(Int_t m1=0,Int_t m2=79) {fFirstSPD1 = m1; fLastSPD1 = m2;} - void SetSPD2Modules(Int_t m1=80, Int_t m2=239) {fFirstSPD2 = m1; fLastSPD2 = m2;} - void SetMaxDistOnSPD2(Double_t max=0.1) {fMaxDistOnSPD2=max;} - Double_t GetMaxDistOnSPD2() const {return fMaxDistOnSPD2;} - void SetMaxVtxRadius(Double_t maxr=3.5) {fMaxVtxRadius=maxr;} - Double_t GetMaVtxRadius() const {return fMaxVtxRadius;} + void SetFirstLastModules(Int_t ilayer=0,Int_t m1=0,Int_t m2=79) + {fFirst[ilayer] = m1; fLast[ilayer] = m2;} + void SetMaxDistOnOuterLayer(Double_t max=0.1) {fMaxDistOnOuterLayer=max;} + Double_t GetMaxDistOnOuterLayer() const {return fMaxDistOnOuterLayer;} + void SetMaxVtxRadius(Int_t ilayer=0,Double_t maxr=3.5) {fMaxVtxRadius[ilayer]=maxr;} + Double_t GetMaVtxRadius(Int_t ilayer=0) const {return fMaxVtxRadius[ilayer];} void SetMinDist2Vtxs(Double_t mind=0.1) {fMinDist2Vtxs=mind;} Double_t GetMinDist2Vtxs() const {return fMinDist2Vtxs;} private: - Int_t fFirstSPD1; // first module of the first pixel layer used - Int_t fLastSPD1; // last module of the first pixel layer used - Int_t fFirstSPD2; // first module of the second pixel layer used - Int_t fLastSPD2; // last module of the second pixel layer used - Double_t fMaxDistOnSPD2; // max dca between SPD1 tracklet and SPD2 cls - Double_t fMaxVtxRadius; // maximum radial pos of vertex + Int_t fFirst[6]; // first module of each layer + Int_t fLast[6]; // last module of each layer + Double_t fMaxDistOnOuterLayer; // max dca between tracklet & outer layer cls + Double_t fMaxVtxRadius[6]; // maximum radial pos of vertex Double_t fMinDist2Vtxs; // minimum distance between two vertices - ClassDef(AliITSVertexerCosmics,1); + ClassDef(AliITSVertexerCosmics,2); // vertexer for cosmics }; #endif diff --git a/ITS/AliITStrackerSA.cxx b/ITS/AliITStrackerSA.cxx index 80201cda25b..0b5194a0feb 100644 --- a/ITS/AliITStrackerSA.cxx +++ b/ITS/AliITStrackerSA.cxx @@ -59,6 +59,7 @@ fVertexer(0), fListOfTracks(0), fITSclusters(0), fSixPoints(0), +fOuterStartLayer(0), fCluLayer(0), fCluCoord(0){ // Default constructor @@ -82,6 +83,7 @@ fVertexer(0), fListOfTracks(0), fITSclusters(0), fSixPoints(0), +fOuterStartLayer(0), fCluLayer(0), fCluCoord(0) { @@ -112,6 +114,7 @@ fVertexer(0), fListOfTracks(0), fITSclusters(0), fSixPoints(0), +fOuterStartLayer(0), fCluLayer(0), fCluCoord(0) { @@ -140,6 +143,7 @@ fVertexer(vertexer), fListOfTracks(0), fITSclusters(0), fSixPoints(0), +fOuterStartLayer(0), fCluLayer(0), fCluCoord(0) { @@ -169,6 +173,7 @@ fVertexer(tracker.fVertexer), fListOfTracks(tracker.fListOfTracks), fITSclusters(tracker.fITSclusters), fSixPoints(tracker.fSixPoints), +fOuterStartLayer(tracker.fOuterStartLayer), fCluLayer(tracker.fCluLayer), fCluCoord(tracker.fCluCoord) { // Copy constructor @@ -268,6 +273,7 @@ void AliITStrackerSA::Init(){ SetWindowSizes(); fITSclusters = 0; SetSixPoints(); + SetOuterStartLayer(0); SetSAFlag(kFALSE); fListOfTracks=new TObjArray(0,0); fCluLayer = 0; @@ -319,6 +325,7 @@ Int_t AliITStrackerSA::FindTracks(AliESDEvent* event){ } } + //Get primary vertex Double_t primaryVertex[3]; event->GetVertex()->GetXYZ(primaryVertex); //Creates TClonesArray with clusters for each layer. The clusters already used @@ -368,7 +375,6 @@ Int_t AliITStrackerSA::FindTracks(AliESDEvent* event){ } - //Get primary vertex Int_t ntrack=0; //loop on the different windows @@ -454,10 +460,10 @@ Int_t AliITStrackerSA::FindTracks(AliESDEvent* event){ } //if 5/6 points are required, second loop starting - //from second layer, to find tracks with point of - //layer 1 missing - - if(!fSixPoints){ + //from second layer (SPD2), to find tracks with point of + //layer 1 missing + if(!fSixPoints) { + //printf("looking from SPD2\n"); // counter for clusters on each layer Int_t * nn = new Int_t[AliITSgeomTGeo::GetNLayers()-1]; for(Int_t nloop=0;nloop0) { + for(Int_t innLay=1; innLay<=fOuterStartLayer; innLay++) { + printf("Searching from layer %d outward\n",innLay); + // counter for clusters on each layer + Int_t * nn = new Int_t[AliITSgeomTGeo::GetNLayers()-innLay]; + for(Int_t nloop=0;nloopGetEntries(); + while(nclInnLay--){ //loop starting from layer innLay + ResetForFinding(); + Int_t pflag=0; + AliITSRecPoint* cl = (AliITSRecPoint*)fCluLayer[innLay]->At(nclInnLay); + + if(!cl) continue; + AliITSclusterTable* arr = (AliITSclusterTable*)GetClusterCoord(innLay,nclInnLay); + 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(); + + Int_t kk; + for(kk=0;kk=AliITSgeomTGeo::GetNLayers()-innLay){ + AliITStrackV2* tr2 = FitShortTrack(trs,primaryVertex,innLay); + if(tr2==0){ + continue; + } + + AliESDtrack outtrack; + outtrack.UpdateTrackParams(tr2,AliESDtrack::kITSin); + event->AddTrack(&outtrack); + ntrack++; + + } + + delete trs; + }//end loop on clusters of innLay + } //end loop on window sizes + + delete [] nn; + } //end loop on innLay + } //end if(fOuterStartLayer>0) + delete [] firstmod; Info("FindTracks","Number of found tracks: %d",event->GetNumberOfTracks()); @@ -616,7 +696,7 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert Int_t nlist=0; if(end[0]==0) end[0]=1; //for tracks with cluster on layer 0 missing - for(Int_t l1=0;l1At(l1); Double_t x1,y1,z1,sx1,sy1,sz1; Double_t x2,y2,z2,sx2,sy2,sz2; @@ -629,7 +709,7 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert 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]; @@ -637,44 +717,51 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert AliITSRecPoint* cl2 = (AliITSRecPoint*)listlayer[2]->At(l3); if(cl0==0 && cl1!=0) { - p2 = cl2;index1=clind2[l3];mrk1=mark2[l3];lay1=2; p1=cl1; + p2=cl2; + index1=clind1[l2];mrk1=mark1[l2]; + index2=clind2[l3];mrk2=mark2[l3]; + lay1=1; + lay2=2; module1 = p1->GetDetectorIndex()+firstmod[1]; } if(cl0!=0 && cl1==0){ p1=cl0; - p2=cl2;index2=clind2[l3];mrk2=mark2[l3];lay2=2; + p2=cl2;index2=clind2[l3];mrk2=mark2[l3]; + lay1=0; + lay2=2; module1 = p1->GetDetectorIndex()+firstmod[0]; } if(cl0!=0 && cl1!=0){ p1=cl0; p2=cl1; + lay1=0; + lay2=1; 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(); + AliITSclusterTable* arr1 = (AliITSclusterTable*)GetClusterCoord(lay1,cln1); + AliITSclusterTable* arr2 = (AliITSclusterTable*)GetClusterCoord(lay2,cln2); + x1 = arr1->GetX(); + x2 = arr2->GetX(); + y1 = arr1->GetY(); + y2 = arr2->GetY(); + z1 = arr1->GetZ(); + z2 = arr2->GetZ(); + sx1 = arr1->GetSx(); + sx2 = arr2->GetSx(); + sy1 = arr1->GetSy(); + sy2 = arr2->GetSy(); + sz1 = arr1->GetSz(); + sz2 = arr2->GetSz(); Int_t layer,ladder,detector; AliITSgeomTGeo::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 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)); @@ -718,12 +805,12 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert ot->ResetCovariance(10.); ot->ResetClusters(); - if(RefitAt(49.,ot,trac)){ //fit from layer 1 to layer 6 + if(RefitAt(krInsideITSscreen,ot,trac)){ //fit from layer 1 to layer 6 AliITStrackMI *otrack2 = new AliITStrackMI(*ot); otrack2->ResetCovariance(10.); otrack2->ResetClusters(); //fit from layer 6 to layer 1 - if(RefitAt(3.7,otrack2,ot)) { + if(RefitAt(krInsideSPD1,otrack2,ot)) { fListOfTracks->AddLast(otrack2); new (tri[nlist]) AliITStrackSA(*trac); nlist++; @@ -737,8 +824,7 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert 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 @@ -833,6 +919,300 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert } +//________________________________________________________________________ + +AliITStrackV2* AliITStrackerSA::FitShortTrack(AliITStrackSA* tr,Double_t *primaryVertex,Int_t innLay){ + //fit of the found track (short tracks, <6 points, for cosmics). A.Dainese 31.07.07 + + + Int_t * firstmod = new Int_t[AliITSgeomTGeo::GetNLayers()]; + for(Int_t i=0;iGetNumberOfClustersSA(); + TObjArray** listlayer = new TObjArray*[AliITSgeomTGeo::GetNLayers()]; + for(Int_t i=0;iGetClusterIndexSA(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]++;} + } + delete [] nnn; + + 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]++;} + + } + } + + delete [] kkk; + + + Int_t * end = new Int_t[AliITSgeomTGeo::GetNLayers()]; + for(Int_t i=0;iGetEntries()==0) end[i]=1; + else end[i]=listlayer[i]->GetEntries(); + } + + TClonesArray* listSA = new TClonesArray("AliITStrackSA"); + TClonesArray &tri = *listSA; + Int_t nlist=0; + + // if(end[0]==0) end[0]=1; //for tracks with cluster on layer 0 missing + for(Int_t l1=0;l1At(l1); + for(Int_t l2=0;l2At(l2); + for(Int_t l3=0;l3At(l3); + for(Int_t l4=0;l4At(l4); + for(Int_t l5=0;l5At(l5); + for(Int_t l6=0;l6At(l6); + + + 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=0,index2=0; + Int_t mrk1=0,mrk2=0; + if(innLay==1) { + p1=cl1; + p2=cl2; + index1=clind1[l2];mrk1=mark1[l2]; + index2=clind2[l3];mrk2=mark2[l3]; + } else if(innLay==2) { + p1=cl2; + p2=cl3; + index1=clind2[l3];mrk1=mark2[l3]; + index2=clind3[l4];mrk2=mark3[l4]; + } else if(innLay==3) { + p1=cl3; + p2=cl4; + index1=clind3[l4];mrk1=mark3[l4]; + index2=clind4[l5];mrk2=mark4[l5]; + } else if(innLay==4) { + p1=cl4; + p2=cl5; + index1=clind4[l5];mrk1=mark4[l5]; + index2=clind5[l6];mrk2=mark5[l6]; + } + Int_t lay1=innLay; + Int_t lay2=innLay+1; + Int_t module1 = p1->GetDetectorIndex()+firstmod[innLay]; + + Int_t cln1=mrk1; + Int_t cln2=mrk2; + AliITSclusterTable* arr1 = (AliITSclusterTable*)GetClusterCoord(lay1,cln1); + AliITSclusterTable* arr2 = (AliITSclusterTable*)GetClusterCoord(lay2,cln2); + x1 = arr1->GetX(); + x2 = arr2->GetX(); + y1 = arr1->GetY(); + y2 = arr2->GetY(); + z1 = arr1->GetZ(); + z2 = arr2->GetZ(); + sx1 = arr1->GetSx(); + sx2 = arr2->GetSx(); + sy1 = arr1->GetSy(); + sy2 = arr2->GetSy(); + sz1 = arr1->GetSz(); + sz2 = arr2->GetSz(); + + Int_t layer,ladder,detector; + AliITSgeomTGeo::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)); + //printf("phi2: %f tgl2: %f\n",phi2,tgl2); + AliITStrackSA* trac = new AliITStrackSA(layer,ladder,detector,yclu1,zclu1,phi2,tgl2,cv,1); + + //Float_t clxyz[3]; + if(cl5!=0) { + trac->AddClusterV2(5,(clind5[l6] & 0x0fffffff)>>0); + trac->AddClusterMark(5,mark5[l6]); + //cl5->GetGlobalXYZ(clxyz);printf("gcl %f %f %f\n",clxyz[0],clxyz[1],clxyz[2]); + } + if(cl4!=0){ + trac->AddClusterV2(4,(clind4[l5] & 0x0fffffff)>>0); + trac->AddClusterMark(4,mark4[l5]); + //cl4->GetGlobalXYZ(clxyz);printf("gcl %f %f %f\n",clxyz[0],clxyz[1],clxyz[2]); + } + if(cl3!=0){ + trac->AddClusterV2(3,(clind3[l4] & 0x0fffffff)>>0); + trac->AddClusterMark(3,mark3[l4]); + //cl3->GetGlobalXYZ(clxyz);printf("gcl %f %f %f\n",clxyz[0],clxyz[1],clxyz[2]); + } + if(cl2!=0){ + trac->AddClusterV2(2,(clind2[l3] & 0x0fffffff)>>0); + trac->AddClusterMark(2,mark2[l3]); + //cl2->GetGlobalXYZ(clxyz);printf("gcl %f %f %f\n",clxyz[0],clxyz[1],clxyz[2]); + } + if(cl1!=0){ + trac->AddClusterV2(1,(clind1[l2] & 0x0fffffff)>>0); + trac->AddClusterMark(1,mark1[l2]); + //cl1->GetGlobalXYZ(clxyz);printf("gcl %f %f %f\n",clxyz[0],clxyz[1],clxyz[2]); + } + if(cl0!=0){ + trac->AddClusterV2(0,(clind0[l1] & 0x0fffffff)>>0); + trac->AddClusterMark(0,mark0[l1]); + //cl0->GetGlobalXYZ(clxyz);printf("gcl %f %f %f\n",clxyz[0],clxyz[1],clxyz[2]); + } + + + //fit with Kalman filter using AliITStrackerMI::RefitAt() + AliITStrackMI* ot = new AliITStrackSA(*trac); + + ot->ResetCovariance(10.); + ot->ResetClusters(); + + //printf("%d \n",trac->GetNumberOfClusters());for(Int_t ijk=0;ijkGetNumberOfClusters();ijk++) printf(" %d",trac->GetClusterIndex(ijk)); printf("\n"); + if(RefitAt(krInsideITSscreen,ot,trac)){ //fit from layer 1 to layer 6 + AliITStrackMI *otrack2 = new AliITStrackMI(*ot); + otrack2->ResetCovariance(10.); + otrack2->ResetClusters(); + //fit from layer 6 to layer 1 + if(RefitAt(krInsideSPD1,otrack2,ot)) { + fListOfTracks->AddLast(otrack2); + new (tri[nlist]) AliITStrackSA(*trac); + nlist++; + } else { + delete otrack2; + } + + } + + delete ot; + delete trac; + }//end loop layer 6 + }//end loop layer 5 + }//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;iDelete(); + delete listSA; + delete [] firstmod; + return 0; + } + + Int_t lowchi2 = FindTrackLowChiSquare(fListOfTracks,dim); + AliITStrackV2* otrack =(AliITStrackV2*)fListOfTracks->At(lowchi2); + AliITStrackSA* trsa = (AliITStrackSA*)listSA->At(lowchi2); + + if(otrack==0) { + for(Int_t i=0;iDelete(); + delete listSA; + delete [] firstmod; + return 0; + } + Int_t * indexc = new Int_t[AliITSgeomTGeo::GetNLayers()]; + for(Int_t i=0;iGetNumberOfClusters();nind++){ + indexc[nind] = otrack->GetClusterIndex(nind); + } + 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; + } + } + delete [] indexc; + Int_t numberofpoints=AliITSgeomTGeo::GetNLayers()-innLay; + CookLabel(otrack,0.); //MI change - to see fake ratio + + 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;iSetLabel(label); + + //remove clusters of found track + for(Int_t nlay=0;nlayGetNumberOfMarked(nlay);cln++){ + Int_t index = trsa->GetClusterMark(nlay,cln); + fCluLayer[nlay]->RemoveAt(index); + RemoveClusterCoord(nlay,index); + fCluLayer[nlay]->Compress(); + } + } + listSA->Delete(); + delete listSA; + + for(Int_t i=0;i(AliITSgeomTGeo::GetNLayers()-2)) osl=AliITSgeomTGeo::GetNLayers()-2; fOuterStartLayer = osl;} + Int_t GetOuterStartLayer() const {return fOuterStartLayer;} void SetSAFlag(Bool_t fl){fITSStandAlone=fl;} // StandAlone flag setter Bool_t GetSAFlag() const {return fITSStandAlone;} // StandAlone flag getter void SetWindowSizes(Int_t n=46, Double_t *phi=0, Double_t *lam=0); @@ -104,11 +106,12 @@ class AliITStrackerSA : public AliITStrackerMI { TObjArray *fListOfTracks; //! container for found tracks TTree *fITSclusters; //! pointer to ITS tree of clusters Bool_t fSixPoints; // If true 6/6 points are required (default). 5/6 otherwise + Int_t fOuterStartLayer; // Search for tracks with <6 points: outer layer to start from TClonesArray** fCluLayer; //! array with clusters TClonesArray** fCluCoord; //! array with cluster info - ClassDef(AliITStrackerSA,5) + ClassDef(AliITStrackerSA,6) }; #endif -- 2.39.3