#include "AliITStrackSA.h"
#include "AliITStrackerSA.h"
#include "AliITSReconstructor.h"
+#include "AliLog.h"
#include "AliRun.h"
ClassImp(AliITStrackerSA)
else {
AliDebug(1,"Stand Alone flag set: doing tracking in ITS alone\n");
}
- if(!rc) rc=FindTracks(event);
+ if(!rc){
+ rc=FindTracks(event,kFALSE);
+ if(AliITSReconstructor::GetRecoParam()->GetSAUseAllClusters()==kTRUE) {
+ rc=FindTracks(event,kTRUE);
+ }
+ }
+
return rc;
}
//______________________________________________________________________
-Int_t AliITStrackerSA::FindTracks(AliESDEvent* event){
+Int_t AliITStrackerSA::FindTracks(AliESDEvent* event, Bool_t useAllClusters){
// Track finder using the ESD object
+ 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();
- if(AliITSReconstructor::GetRecoParam()->GetSAUseAllClusters()==kFALSE) {
+ if(!useAllClusters) {
while (nentr--) {
AliESDtrack *track=event->GetTrack(nentr);
if ((track->GetStatus()&AliESDtrack::kITSin) == AliESDtrack::kITSin){
}
}
}
+ }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;k<ncl;k++){
+ AliITSRecPoint* cll = (AliITSRecPoint*)GetCluster(idx[k]);
+ cll->ResetBit(kSAflag);
+ }
+ }
+ }
}
//Get primary vertex
Double_t primaryVertex[3];
}
for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++){
AliITSlayer &layer=fgLayers[i];
- if (!AliITSReconstructor::GetRecoParam()->GetLayersToSkip(i)) {
+ if (!ForceSkippingOfLayer(i)) {
for(Int_t cli=0;cli<layer.GetNumberOfClusters();cli++){
AliITSRecPoint* cls = (AliITSRecPoint*)layer.GetCluster(cli);
if(cls->TestBit(kSAflag)==kTRUE) continue; //clusters used by TPC prol.
}
}
dmar[i]=0;
- delete fCluLayer[i];
- fCluLayer[i] = new TClonesArray("AliITSRecPoint",nclusters[i]);
- delete fCluCoord[i];
- fCluCoord[i] = new TClonesArray("AliITSclusterTable",nclusters[i]);
+ 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]);
+ }
}
for(Int_t ilay=0;ilay<AliITSgeomTGeo::GetNLayers();ilay++){
TClonesArray &clulay = *fCluLayer[ilay];
TClonesArray &clucoo = *fCluCoord[ilay];
AliITSlayer &layer=fgLayers[ilay];
- if (!AliITSReconstructor::GetRecoParam()->GetLayersToSkip(ilay)) {
+ if (!ForceSkippingOfLayer(ilay)) {
for(Int_t cli=0;cli<layer.GetNumberOfClusters();cli++){
AliITSRecPoint* cls = (AliITSRecPoint*)layer.GetCluster(cli);
if(cls->TestBit(kSAflag)==kTRUE) continue;
static Int_t nClusLay[AliITSgeomTGeo::kNLayers];//counter for clusters on each layer
- if(AliITSReconstructor::GetRecoParam()->GetAllowProlongationWithEmptyRoad()) fMinNPoints=2;
-
-
// loop on minimum number of points
for(Int_t iMinNPoints=AliITSgeomTGeo::GetNLayers(); iMinNPoints>=fMinNPoints; iMinNPoints--) {
if(!fInwardFlag){ // Tracking outwards from the inner layers
// loop on starting layer for track finding
for(Int_t innLay=0; innLay<=fOuterStartLayer; innLay++) {
- if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(innLay)) continue;
+ if(ForceSkippingOfLayer(innLay)) continue;
Int_t minNPoints=iMinNPoints-innLay;
for(Int_t i=innLay+1;i<AliITSgeomTGeo::GetNLayers();i++)
- if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(i))
+ if(ForceSkippingOfLayer(i))
minNPoints--;
if(minNPoints<fMinNPoints) continue;
if(nClusLay[nnp]!=0) layOK+=1;
}
if(layOK>=minNPoints){
- //printf("---NPOINTS: %d; MAP: %d %d %d %d %d %d\n",layOK,nClusLay[0],nClusLay[1],nClusLay[2],nClusLay[3],nClusLay[4],nClusLay[5]);
+ 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;
- //printf("---NPOINTS fit: %d\n",tr2->GetNumberOfClusters());
+ if(!tr2){
+ delete trs;
+ continue;
+ }
+ AliDebug(2,Form("---NPOINTS fit: %d\n",tr2->GetNumberOfClusters()));
- StoreTrack(tr2,event);
+ StoreTrack(tr2,event,useAllClusters);
ntrack++;
}
// loop on starting layer for track finding
for(Int_t outLay=AliITSgeomTGeo::GetNLayers()-1; outLay>=fInnerStartLayer; outLay--) {
- if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(outLay)) continue;
+ if(ForceSkippingOfLayer(outLay)) continue;
Int_t minNPoints=iMinNPoints-(AliITSgeomTGeo::GetNLayers()-1-outLay);
for(Int_t i=0;i<outLay-1;i++)
- if(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(i))
+ if(ForceSkippingOfLayer(i))
minNPoints--;
if(minNPoints<fMinNPoints) continue;
if(nClusLay[nnp]!=0) layOK+=1;
}
if(layOK>=minNPoints){
- //printf("---NPOINTS: %d; MAP: %d %d %d %d %d %d\n",layOK,nClusLay[0],nClusLay[1],nClusLay[2],nClusLay[3],nClusLay[4],nClusLay[5]);
+ 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;
- //printf("---NPOINTS fit: %d\n",tr2->GetNumberOfClusters());
+ if(!tr2){
+ delete trs;
+ continue;
+ }
+ AliDebug(2,Form("---NPOINTS fit: %d\n",tr2->GetNumberOfClusters()));
- StoreTrack(tr2,event);
+ StoreTrack(tr2,event,useAllClusters);
ntrack++;
}
if(nClusLay[nnp]!=0) layOK+=1;
}
if(layOK==1) {
- //printf("----NPOINTS: %d; MAP: %d %d %d %d %d %d\n",layOK,nClusLay[0],nClusLay[1],nClusLay[2],nClusLay[3],nClusLay[4],nClusLay[5]);
+ 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;
Bool_t onePoint = kTRUE;
tr2 = FitTrack(trs,primaryVertex,onePoint);
- if(!tr2) continue;
- //printf("----NPOINTS fit: %d\n",tr2->GetNumberOfClusters());
+ if(!tr2){
+ delete trs;
+ continue;
+ }
+ AliDebug(2,Form("----NPOINTS fit: %d\n",tr2->GetNumberOfClusters()));
- StoreTrack(tr2,event);
+ StoreTrack(tr2,event,useAllClusters);
ntrack++;
}
} //end loop on innLay
} // end search 1-point tracks
- Info("FindTracks","Number of found tracks: %d",event->GetNumberOfTracks());
+ if(!useAllClusters) AliInfo(Form("Number of found tracks: %d",event->GetNumberOfTracks()));
+ ResetForFinding();
return 0;
}
static Int_t clind[AliITSgeomTGeo::kNLayers][kMaxClu];
static Int_t clmark[AliITSgeomTGeo::kNLayers][kMaxClu];
- static Int_t nnn[AliITSgeomTGeo::kNLayers];
- static Int_t kkk[AliITSgeomTGeo::kNLayers];
static Int_t end[AliITSgeomTGeo::kNLayers];
static AliITSRecPoint *listlayer[AliITSgeomTGeo::kNLayers][kMaxClu];
for(Int_t i=0;i<AliITSgeomTGeo::GetNLayers();i++) {
firstmod[i]=AliITSgeomTGeo::GetModuleIndex(i+1,1,1);
- nnn[i]=0;
- kkk[i]=0;
end[i]=0;
for(Int_t j=0;j<kMaxClu; j++){
clind[i][j]=0;
Int_t lay = (index & 0xf0000000) >> 28;
Int_t nInLay=end[lay];
listlayer[lay][nInLay]=cl;
- Int_t ind=nnn[lay];
- clind[lay][ind]=index;
+ clind[lay][nInLay]=index;
end[lay]++;
}
for(Int_t nlay=0;nlay<AliITSgeomTGeo::GetNLayers();nlay++){
for(Int_t ncl=0;ncl<tr->GetNumberOfMarked(nlay);ncl++){
Int_t mark = tr->GetClusterMark(nlay,ncl);
- Int_t ind=kkk[nlay];
- clmark[nlay][ind]=mark;
+ clmark[nlay][ncl]=mark;
}
}
ot->ResetCovariance(10.);
ot->ResetClusters();
- if(RefitAt(AliITSRecoParam::GetrInsideITSscreen(),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(AliITSRecoParam::GetrInsideSPD1(),otrack2,ot)) {
- fListOfTracks->AddLast(otrack2);
- fListOfSATracks->AddLast(trac);
- } else {
- delete otrack2;
- delete trac;
- }
+ // 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 = new AliITStrackMI(*ot);
+ otrack2->ResetCovariance(10.);
+ otrack2->ResetClusters();
+ //fit from layer 6 to layer 1
+ if(RefitAt(AliITSRecoParam::GetrInsideSPD1(),otrack2,ot)) {
+ fListOfTracks->AddLast(otrack2);
+ fListOfSATracks->AddLast(trac);
+ } else {
+ delete otrack2;
+ delete trac;
+ }
- }
-
+ }
+ }
delete ot;
}//end loop layer 6
}//end loop layer 5
}
//_______________________________________________________
-void AliITStrackerSA::StoreTrack(AliITStrackV2 *t,AliESDEvent *event) const
+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(AliITSReconstructor::GetRecoParam()->GetLayersToSkip(layer)) return 0;
+ if(ForceSkippingOfLayer(layer)) return 0;
Int_t nc=0;
AliITSlayer &lay = fgLayers[layer];
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff