/*
$Log$
+Revision 1.23 2002/11/19 11:50:08 hristov
+Removing CONTAINERS (Yu.Belikov)
+
+Revision 1.19 2002/07/19 07:31:40 kowal2
+Improvement in tracking by J. Belikov
+
Revision 1.18 2002/05/13 07:33:52 kowal2
Added protection in Int_t AliTPCtracker::AliTPCRow::Find(Double_t y) const
in the case of defined region of interests.
//
// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------
-
#include <TObjArray.h>
#include <TFile.h>
#include <TTree.h>
-#include <iostream.h>
+#include <Riostream.h>
#include "AliTPCtracker.h"
#include "AliTPCcluster.h"
#include "AliTPCParam.h"
-#include "AliTPCClustersRow.h"
+#include "AliClusters.h"
+#include <stdlib.h>
//_____________________________________________________________________________
-AliTPCtracker::AliTPCtracker(const AliTPCParam *par, Int_t eventn):
+AliTPCtracker::AliTPCtracker(const AliTPCParam *par):
AliTracker(), fkNIS(par->GetNInnerSector()/2), fkNOS(par->GetNOuterSector()/2)
{
//---------------------------------------------------------------------
for (i=0; i<fkNIS; i++) fInnerSec[i].Setup(par,0);
for (i=0; i<fkNOS; i++) fOuterSec[i].Setup(par,1);
- fN=0; fSectors=0;
-
- fClustersArray.Setup(par);
- fClustersArray.SetClusterType("AliTPCcluster");
-
- char cname[100];
- if (eventn==-1) {
- sprintf(cname,"TreeC_TPC");
- }
- else {
- sprintf(cname,"TreeC_TPC_%d",eventn);
- }
-
- fClustersArray.ConnectTree(cname);
-
- fEventN = eventn;
fSeeds=0;
}
}
//_____________________________________________________________________________
-void AliTPCtracker::LoadOuterSectors() {
+void AliTPCtracker::LoadClusters() {
//-----------------------------------------------------------------
- // This function fills outer TPC sectors with clusters.
+ // This function loads TPC clusters.
//-----------------------------------------------------------------
- UInt_t index;
- Int_t j=Int_t(fClustersArray.GetTree()->GetEntries());
- for (Int_t i=0; i<j; i++) {
- AliSegmentID *s=fClustersArray.LoadEntry(i);
- Int_t sec,row;
- AliTPCParam *par=(AliTPCParam*)fClustersArray.GetParam();
- par->AdjustSectorRow(s->GetID(),sec,row);
- if (sec<fkNIS*2) continue;
- AliTPCClustersRow *clrow=fClustersArray.GetRow(sec,row);
- Int_t ncl=clrow->GetArray()->GetEntriesFast();
- while (ncl--) {
- AliTPCcluster *c=(AliTPCcluster*)(*clrow)[ncl];
- index=(((sec<<8)+row)<<16)+ncl;
- fOuterSec[(sec-fkNIS*2)%fkNOS][row].InsertCluster(c,index);
- }
+ if (!gFile->IsOpen()) {
+ cerr<<"AliTPCtracker::LoadClusters : "<<
+ "file with clusters has not been open !\n";
+ return;
}
- fN=fkNOS;
- fSectors=fOuterSec;
-}
-
-//_____________________________________________________________________________
-void AliTPCtracker::UnloadOuterSectors() {
- //-----------------------------------------------------------------
- // This function clears outer TPC sectors.
- //-----------------------------------------------------------------
- Int_t nup=fOuterSec->GetNRows();
- for (Int_t i=0; i<fkNOS; i++) {
- for (Int_t j=0; j<nup; j++) {
- if (fClustersArray.GetRow(i+fkNIS*2,j))
- fClustersArray.ClearRow(i+fkNIS*2,j);
- if (fClustersArray.GetRow(i+fkNIS*2+fkNOS,j))
- fClustersArray.ClearRow(i+fkNIS*2+fkNOS,j);
- }
+ Char_t name[100];
+ sprintf(name,"TreeC_TPC_%d",GetEventNumber());
+ TTree *cTree=(TTree*)gFile->Get(name);
+ if (!cTree) {
+ cerr<<"AliTPCtracker::LoadClusters : "<<
+ "can't get the tree with TPC clusters !\n";
+ return;
}
- fN=0;
- fSectors=0;
-}
-
-//_____________________________________________________________________________
-void AliTPCtracker::LoadInnerSectors() {
- //-----------------------------------------------------------------
- // This function fills inner TPC sectors with clusters.
- //-----------------------------------------------------------------
- UInt_t index;
- Int_t j=Int_t(fClustersArray.GetTree()->GetEntries());
- for (Int_t i=0; i<j; i++) {
- AliSegmentID *s=fClustersArray.LoadEntry(i);
- Int_t sec,row;
- AliTPCParam *par=(AliTPCParam*)fClustersArray.GetParam();
- par->AdjustSectorRow(s->GetID(),sec,row);
- if (sec>=fkNIS*2) continue;
- AliTPCClustersRow *clrow=fClustersArray.GetRow(sec,row);
- Int_t ncl=clrow->GetArray()->GetEntriesFast();
- while (ncl--) {
- AliTPCcluster *c=(AliTPCcluster*)(*clrow)[ncl];
- index=(((sec<<8)+row)<<16)+ncl;
- fInnerSec[sec%fkNIS][row].InsertCluster(c,index);
- }
+ TBranch *branch=cTree->GetBranch("Segment");
+ if (!branch) {
+ cerr<<"AliTPCtracker::LoadClusters : "<<
+ "can't get the segment branch !\n";
+ return;
}
+ AliClusters carray, *addr=&carray; carray.SetClass("AliTPCcluster");
+ branch->SetAddress(&addr);
+
+ Int_t nentr=(Int_t)cTree->GetEntries();
+
+ for (Int_t i=0; i<nentr; i++) {
+ cTree->GetEvent(i);
+
+ Int_t ncl=carray.GetArray()->GetEntriesFast();
+
+ Int_t nir=fInnerSec->GetNRows(), nor=fOuterSec->GetNRows();
+ Int_t id=carray.GetID();
+ if ((id<0) || (id>2*(fkNIS*nir + fkNOS*nor))) {
+ cerr<<"AliTPCtracker::LoadClusters : "<<
+ "wrong index !\n";
+ exit(1);
+ }
+ Int_t outindex = 2*fkNIS*nir;
+ if (id<outindex) {
+ Int_t sec = id/nir;
+ Int_t row = id - sec*nir;
+ sec %= fkNIS;
+ AliTPCRow &padrow=fInnerSec[sec][row];
+ while (ncl--) {
+ AliTPCcluster *c=(AliTPCcluster*)carray[ncl];
+ padrow.InsertCluster(c,sec,row);
+ }
+ } else {
+ id -= outindex;
+ Int_t sec = id/nor;
+ Int_t row = id - sec*nor;
+ sec %= fkNOS;
+ AliTPCRow &padrow=fOuterSec[sec][row];
+ while (ncl--) {
+ AliTPCcluster *c=(AliTPCcluster*)carray[ncl];
+ padrow.InsertCluster(c,sec+fkNIS,row);
+ }
+ }
- fN=fkNIS;
- fSectors=fInnerSec;
+ carray.GetArray()->Clear();
+ }
+ delete cTree;
}
//_____________________________________________________________________________
-void AliTPCtracker::UnloadInnerSectors() {
+void AliTPCtracker::UnloadClusters() {
//-----------------------------------------------------------------
- // This function clears inner TPC sectors.
+ // This function unloads TPC clusters.
//-----------------------------------------------------------------
- Int_t nlow=fInnerSec->GetNRows();
- for (Int_t i=0; i<fkNIS; i++) {
- for (Int_t j=0; j<nlow; j++) {
- if (fClustersArray.GetRow(i,j)) fClustersArray.ClearRow(i,j);
- if (fClustersArray.GetRow(i+fkNIS,j)) fClustersArray.ClearRow(i+fkNIS,j);
- }
+ Int_t i;
+ for (i=0; i<fkNIS; i++) {
+ Int_t nr=fInnerSec->GetNRows();
+ for (Int_t n=0; n<nr; n++) fInnerSec[i][n].ResetClusters();
+ }
+ for (i=0; i<fkNOS; i++) {
+ Int_t nr=fOuterSec->GetNRows();
+ for (Int_t n=0; n<nr; n++) fOuterSec[i][n].ResetClusters();
}
-
- fN=0;
- fSectors=0;
}
//_____________________________________________________________________________
idx=track.GetClusterIndex(nc);
sec=(idx&0xff000000)>>24; row=(idx&0x00ff0000)>>16;
}
- if (fSectors==fInnerSec) { if (sec >= 2*fkNIS) row=-1; }
- else { if (sec < 2*fkNIS) row=-1; }
+ if (fSectors==fInnerSec) { if (sec >= fkNIS) row=-1; }
+ else { if (sec < fkNIS) row=-1; }
Int_t nr=fSectors->GetNRows();
for (Int_t i=0; i<nr; i++) {
idx=track.GetClusterIndex(nc);
sec=(idx&0xff000000)>>24; row=(idx&0x00ff0000)>>16;
}
- if (fSectors==fInnerSec) { if (sec >= 2*fkNIS) row=-1; }
- else { if (sec < 2*fkNIS) row=-1; }
+ if (fSectors==fInnerSec) { if (sec >= fkNIS) row=-1; }
+ else { if (sec < fkNIS) row=-1; }
}
if (!cl) {
//-----------------------------------------------------------------
// This function creates track seeds.
//-----------------------------------------------------------------
- if (fSeeds==0) fSeeds=new TObjArray(15000);
-
Double_t x[5], c[15];
- Double_t alpha=fOuterSec->GetAlpha(), shift=fOuterSec->GetAlphaShift();
+ Double_t alpha=fSectors->GetAlpha(), shift=fSectors->GetAlphaShift();
Double_t cs=cos(alpha), sn=sin(alpha);
- Double_t x1 =fOuterSec->GetX(i1);
- Double_t xx2=fOuterSec->GetX(i2);
+ Double_t x1 =fSectors->GetX(i1);
+ Double_t xx2=fSectors->GetX(i2);
- for (Int_t ns=0; ns<fkNOS; ns++) {
- Int_t nl=fOuterSec[(ns-1+fkNOS)%fkNOS][i2];
- Int_t nm=fOuterSec[ns][i2];
- Int_t nu=fOuterSec[(ns+1)%fkNOS][i2];
- const AliTPCRow& kr1=fOuterSec[ns][i1];
+ for (Int_t ns=0; ns<fN; ns++) {
+ Int_t nl=fSectors[(ns-1+fN)%fN][i2];
+ Int_t nm=fSectors[ns][i2];
+ Int_t nu=fSectors[(ns+1)%fN][i2];
+ const AliTPCRow& kr1=fSectors[ns][i1];
for (Int_t is=0; is < kr1; is++) {
Double_t y1=kr1[is]->GetY(), z1=kr1[is]->GetZ();
for (Int_t js=0; js < nl+nm+nu; js++) {
Double_t x3=GetX(), y3=GetY(), z3=GetZ();
if (js<nl) {
- const AliTPCRow& kr2=fOuterSec[(ns-1+fkNOS)%fkNOS][i2];
+ const AliTPCRow& kr2=fSectors[(ns-1+fN)%fN][i2];
kcl=kr2[js];
y2=kcl->GetY(); z2=kcl->GetZ();
x2= xx2*cs+y2*sn;
y2=-xx2*sn+y2*cs;
} else
if (js<nl+nm) {
- const AliTPCRow& kr2=fOuterSec[ns][i2];
+ const AliTPCRow& kr2=fSectors[ns][i2];
kcl=kr2[js-nl];
x2=xx2; y2=kcl->GetY(); z2=kcl->GetZ();
} else {
- const AliTPCRow& kr2=fOuterSec[(ns+1)%fkNOS][i2];
+ const AliTPCRow& kr2=fSectors[(ns+1)%fN][i2];
kcl=kr2[js-nl-nm];
y2=kcl->GetY(); z2=kcl->GetZ();
x2=xx2*cs-y2*sn;
UInt_t index=kr1.GetIndex(is);
AliTPCseed *track=new AliTPCseed(index, x, c, x1, ns*alpha+shift);
- Float_t l=fOuterSec->GetPadPitchWidth();
+ Float_t l=fSectors->GetPadPitchWidth();
track->SetSampledEdx(kr1[is]->GetQ()/l,0);
Int_t rc=FollowProlongation(*track, i2);
return 2;
}
+ LoadClusters();
+
out->cd();
char tname[100];
- sprintf(tname,"TreeT_TPC_%d",fEventN);
+ sprintf(tname,"TreeT_TPC_%d",GetEventNumber());
TTree tracktree(tname,"Tree with TPC tracks");
AliTPCtrack *iotrack=0;
tracktree.Branch("tracks","AliTPCtrack",&iotrack,32000,0);
- LoadOuterSectors();
-
//find track seeds
Int_t nup=fOuterSec->GetNRows(), nlow=fInnerSec->GetNRows();
Int_t nrows=nlow+nup;
if (fSeeds==0) {
Int_t gap=Int_t(0.125*nrows), shift=Int_t(0.5*gap);
+ fSectors=fOuterSec; fN=fkNOS;
+ fSeeds=new TObjArray(15000);
MakeSeeds(nup-1, nup-1-gap);
MakeSeeds(nup-1-shift, nup-1-shift-gap);
- }
+ }
fSeeds->Sort();
- //tracking in outer sectors
+ Int_t found=0;
Int_t nseed=fSeeds->GetEntriesFast();
- Int_t i;
- for (i=0; i<nseed; i++) {
+ for (Int_t i=0; i<nseed; i++) {
+ //tracking in the outer sectors
+ fSectors=fOuterSec; fN=fkNOS;
+
AliTPCseed *pt=(AliTPCseed*)fSeeds->UncheckedAt(i), &t=*pt;
- if (FollowProlongation(t)) {
- UseClusters(&t);
+ if (!FollowProlongation(t)) {
+ delete fSeeds->RemoveAt(i);
continue;
}
- delete fSeeds->RemoveAt(i);
- }
- //UnloadOuterSectors();
- //tracking in inner sectors
- LoadInnerSectors();
- Int_t found=0;
- for (i=0; i<nseed; i++) {
- AliTPCseed *pt=(AliTPCseed*)fSeeds->UncheckedAt(i), &t=*pt;
- if (!pt) continue;
- Int_t nc=t.GetNumberOfClusters();
+ //tracking in the inner sectors
+ fSectors=fInnerSec; fN=fkNIS;
Double_t alpha=t.GetAlpha() - fInnerSec->GetAlphaShift();
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
if (alpha < 0. ) alpha += 2.*TMath::Pi();
Int_t ns=Int_t(alpha/fInnerSec->GetAlpha())%fkNIS;
- alpha=ns*fInnerSec->GetAlpha() + fInnerSec->GetAlphaShift() - t.GetAlpha();
+ alpha=ns*fInnerSec->GetAlpha()+fInnerSec->GetAlphaShift()-t.GetAlpha();
if (t.Rotate(alpha)) {
if (FollowProlongation(t)) {
CookLabel(pt,0.1); //For comparison only
iotrack=pt;
tracktree.Fill();
- UseClusters(&t,nc);
+ UseClusters(&t);
cerr<<found++<<'\r';
}
}
}
delete fSeeds->RemoveAt(i);
- }
- UnloadInnerSectors();
- UnloadOuterSectors();
+ }
tracktree.Write();
savedir->cd();
+ UnloadClusters();
+ fSeeds->Clear(); delete fSeeds; fSeeds=0;
+
return 0;
}
return 2;
}
+ LoadClusters();
+
in->cd();
TTree *bckTree=(TTree*)in->Get("TreeT_ITSb_0");
if (!bckTree) {
backTree.Branch("tracks","AliTPCtrack",&otrack,32000,0);
//*** Back propagation through inner sectors
- LoadInnerSectors();
+ fSectors=fInnerSec; fN=fkNIS;
Int_t nseed=fSeeds->GetEntriesFast();
for (i=0; i<nseed; i++) {
AliTPCseed *ps=(AliTPCseed*)fSeeds->UncheckedAt(i), &s=*ps;
}
delete fSeeds->RemoveAt(i);
}
- UnloadInnerSectors();
//*** Back propagation through outer sectors
- LoadOuterSectors();
+ fSectors=fOuterSec; fN=fkNOS;
Int_t found=0;
for (i=0; i<nseed; i++) {
AliTPCseed *ps=(AliTPCseed*)fSeeds->UncheckedAt(i), &s=*ps;
}
delete fSeeds->RemoveAt(i);
}
- UnloadOuterSectors();
backTree.Write();
savedir->cd();
delete bckTree; //Thanks to Mariana Bondila
delete tpcTree; //Thanks to Mariana Bondila
+ UnloadClusters();
+
return 0;
}
Int_t row=(index&0x00ff0000)>>16;
Int_t ncl=(index&0x0000ffff)>>00;
- AliTPCClustersRow *clrow=((AliTPCtracker *) this)->fClustersArray.GetRow(sec,row);
- return (AliCluster*)(*clrow)[ncl];
+ const AliTPCcluster *cl=0;
+
+ if (sec<fkNIS) {
+ cl=fInnerSec[sec][row].GetUnsortedCluster(ncl);
+ } else {
+ sec-=fkNIS;
+ cl=fOuterSec[sec][row].GetUnsortedCluster(ncl);
+ }
+
+ return (AliCluster*)cl;
}
//__________________________________________________________________________
}
//_________________________________________________________________________
-void
-AliTPCtracker::AliTPCRow::InsertCluster(const AliTPCcluster* c, UInt_t index) {
+void AliTPCtracker::
+AliTPCRow::InsertCluster(const AliTPCcluster* c, Int_t sec, Int_t row) {
//-----------------------------------------------------------------------
// Insert a cluster into this pad row in accordence with its y-coordinate
//-----------------------------------------------------------------------
if (fN==kMaxClusterPerRow) {
cerr<<"AliTPCRow::InsertCluster(): Too many clusters !\n"; return;
}
- if (fN==0) {fIndex[0]=index; fClusters[fN++]=c; return;}
+
+ Int_t index=(((sec<<8)+row)<<16)+fN;
+
+ if (fN==0) {
+ fIndex[0]=index;
+ fClusterArray[0]=*c; fClusters[fN++]=fClusterArray;
+ return;
+ }
+
+ if (fN==fSize) {
+ Int_t size=fSize*2;
+ AliTPCcluster *buff=new AliTPCcluster[size];
+ memcpy(buff,fClusterArray,fSize*sizeof(AliTPCcluster));
+ for (Int_t i=0; i<fN; i++)
+ fClusters[i]=buff+(fClusters[i]-fClusterArray);
+ delete[] fClusterArray;
+ fClusterArray=buff;
+ fSize=size;
+ }
+
Int_t i=Find(c->GetY());
memmove(fClusters+i+1 ,fClusters+i,(fN-i)*sizeof(AliTPCcluster*));
memmove(fIndex +i+1 ,fIndex +i,(fN-i)*sizeof(UInt_t));
- fIndex[i]=index; fClusters[i]=c; fN++;
+ fIndex[i]=index;
+ fClusters[i]=fClusterArray+fN; fClusterArray[fN++]=*c;
}
//___________________________________________________________________
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff