/*
$Log$
+Revision 1.3 2000/10/05 16:03:07 kowal2
+Forward declarations. Destructor made virtual.
+
Revision 1.2 2000/04/17 09:37:33 kowal2
removed obsolete AliTPCDigitsDisplay.C
AliDigitsArray::~AliDigitsArray()
{
- if (fParam != 0) delete fParam;
+ // if (fParam != 0) delete fParam;
}
Bool_t AliDigitsArray::Setup(AliDetectorParam *param)
/*
$Log$
+Revision 1.37 2001/06/12 07:17:18 kowal2
+Hits2SDigits method implemented (summable digits)
+
Revision 1.36 2001/05/16 14:57:25 alibrary
New files for folders and Stack
#include <TObjectTable.h>
#include "TParticle.h"
#include "AliTPC.h"
-#include <TFile.h>
+#include <TFile.h>
+#include <TROOT.h>
+#include <TSystem.h>
#include "AliRun.h"
#include <iostream.h>
#include <stdlib.h>
//MI changes
fDigitsArray = 0;
fClustersArray = 0;
- fTPCParam=0;
+ fDefaults = 0;
fTrackHits = 0;
fHitType = 2;
fTPCParam = 0;
//MI change
fDigitsArray = 0;
fClustersArray= 0;
+ fDefaults = 0;
//
fTrackHits = new AliTPCTrackHits; //MI - 13.09.2000
fTrackHits->SetHitPrecision(0.002);
// Set TPC parameters
//
- if (!strcmp(title,"Default")) {
- fTPCParam = new AliTPCParamSR;
+
+ if (!strcmp(title,"Default")) {
+ fTPCParam = new AliTPCParamSR;
} else {
cerr<<"AliTPC warning: in Config.C you must set non-default parameters\n";
fTPCParam=0;
}
-void AliTPC::Digits2Clusters(TFile *of)
+void AliTPC::Digits2Clusters(TFile *of, Int_t eventnumber)
{
//-----------------------------------------------------------------
// This is a simple cluster finder.
//-----------------------------------------------------------------
- AliTPCclusterer::Digits2Clusters(fTPCParam,of);
+ AliTPCclusterer::Digits2Clusters(fTPCParam,of,eventnumber);
}
extern Double_t SigmaY2(Double_t, Double_t, Double_t);
extern Double_t SigmaZ2(Double_t, Double_t);
//_____________________________________________________________________________
-void AliTPC::Hits2Clusters(TFile *of)
+void AliTPC::Hits2Clusters(TFile *of, Int_t eventn)
{
//--------------------------------------------------------
// TPC simple cluster generator from hits
return;
}
- if(fTPCParam == 0){
- printf("AliTPCParam MUST be created firstly\n");
- return;
- }
+ //if(fDefaults == 0) SetDefaults();
Float_t sigmaRphi,sigmaZ,clRphi,clZ;
//
//Switch to the output file
of->cd();
+ char cname[100];
+
+ sprintf(cname,"TreeC_TPC_%d",eventn);
+
fTPCParam->Write(fTPCParam->GetTitle());
AliTPCClustersArray carray;
carray.Setup(fTPCParam);
cerr<<"Number of made clusters : "<<nclusters<<" \n";
- carray.GetTree()->Write();
+ carray.GetTree()->Write(cname);
savedir->cd(); //switch back to the input file
}
//___________________________________________
-void AliTPC::SDigits2Digits()
+void AliTPC::SDigits2Digits(Int_t eventnumber)
{
+
+
+ cerr<<"Digitizing TPC...\n";
+
+ Hits2Digits(eventnumber);
+
+
+ //write results
+
+ // char treeName[100];
+
+ // sprintf(treeName,"TreeD_%s_%d",fTPCParam->GetTitle(),eventnumber);
+
+ // GetDigitsArray()->GetTree()->Write(treeName);
+}
+//__________________________________________________________________
+void AliTPC::SetDefaults(){
+
+
+ cerr<<"Setting default parameters...\n";
+
+ // Set response functions
+
AliTPCParamSR *param=(AliTPCParamSR*)gDirectory->Get("75x40_100x60");
AliTPCPRF2D * prfinner = new AliTPCPRF2D;
AliTPCPRF2D * prfouter = new AliTPCPRF2D;
AliTPCRF1D * rf = new AliTPCRF1D(kTRUE);
-
- TDirectory *cwd = gDirectory;
rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
rf->SetOffset(3*param->GetZSigma());
rf->Update();
+
+ TDirectory *savedir=gDirectory;
TFile *f=TFile::Open("$ALICE_ROOT/TPC/AliTPCprf2d.root");
if (!f->IsOpen()) {
- cerr<<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !\n";
+ cerr<<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !\n" ;
exit(3);
}
prfinner->Read("prf_07504_Gati_056068_d02");
prfouter->Read("prf_10006_Gati_047051_d03");
f->Close();
- cwd->cd();
-
+ savedir->cd();
+
param->SetInnerPRF(prfinner);
param->SetOuterPRF(prfouter);
param->SetTimeRF(rf);
+ // set fTPCParam
+
SetParam(param);
- cerr<<"Digitizing TPC...\n";
+
+ fDefaults = 1;
+
+}
+//__________________________________________________________________
+void AliTPC::Hits2Digits(Int_t eventnumber)
+{
+ //----------------------------------------------------
+ // Loop over all sectors for a single event
+ //----------------------------------------------------
+
+
+ if(fDefaults == 0) SetDefaults(); // check if the parameters are set
//setup TPCDigitsArray
+
+ if(GetDigitsArray()) delete GetDigitsArray();
+
AliTPCDigitsArray *arr = new AliTPCDigitsArray;
arr->SetClass("AliSimDigits");
- arr->Setup(param);
- SetParam(param);
-
+ arr->Setup(fTPCParam);
arr->MakeTree(fDigitsFile);
-
SetDigitsArray(arr);
- Hits2Digits();
-
- // Hits2DigitsSector(1);
- // Hits2DigitsSector(2);
- // Hits2DigitsSector(3);
- // Hits2DigitsSector(1+18);
- // Hits2DigitsSector(2+18);
- // Hits2DigitsSector(3+18);
-
- // Hits2DigitsSector(36+1);
- // Hits2DigitsSector(36+2);
- // Hits2DigitsSector(36+3);
- // Hits2DigitsSector(36+1+18);
- // Hits2DigitsSector(36+2+18);
- // Hits2DigitsSector(36+3+18);
-
- //write results
+ fDigitsSwitch=0; // standard digits
- char treeName[100];
- sprintf(treeName,"TreeD_%s",param->GetTitle());
- GetDigitsArray()->GetTree()->Write(treeName,TObject::kOverwrite);
-}
+ cerr<<"Digitizing TPC...\n";
-//__________________________________________________________________
-void AliTPC::Hits2Digits()
-{
- //----------------------------------------------------
- // Loop over all sectors
- //----------------------------------------------------
+ for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
- if(fTPCParam == 0){
- printf("AliTPCParam MUST be created firstly\n");
- return;
- }
+ // write results
+
+ char treeName[100];
+
+ sprintf(treeName,"TreeD_%s_%d",fTPCParam->GetTitle(),eventnumber);
- fDigitsSwitch=0;
+ GetDigitsArray()->GetTree()->Write(treeName);
- for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
}
+
+
//__________________________________________________________________
-void AliTPC::Hits2SDigits()
+void AliTPC::Hits2SDigits(Int_t eventnumber)
{
//-----------------------------------------------------------
//-----------------------------------------------------------
//----------------------------------------------------
- // Loop over all sectors
+ // Loop over all sectors for a single event
//----------------------------------------------------
- if(fTPCParam == 0){
- printf("AliTPCParam MUST be created firstly\n");
- return;
- }
-
- fDigitsSwitch=1;
+
+ if(fDefaults == 0) SetDefaults();
+
+ //setup TPCDigitsArray
+
+ if(GetDigitsArray()) delete GetDigitsArray();
+
+ AliTPCDigitsArray *arr = new AliTPCDigitsArray;
+ arr->SetClass("AliSimDigits");
+ arr->Setup(fTPCParam);
+ arr->MakeTree(fDigitsFile);
+ SetDigitsArray(arr);
+
+ cerr<<"Digitizing TPC...\n";
+
+ fDigitsSwitch=1; // summable digits
for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
+
+ // write results
+
+ char treeName[100];
+
+ sprintf(treeName,"TreeS_%s_%d",fTPCParam->GetTitle(),eventnumber);
+
+ GetDigitsArray()->GetTree()->Write(treeName);
+
}
+
+
//_____________________________________________________________________________
void AliTPC::Hits2DigitsSector(Int_t isec)
{
// Get the access to the track hits
//-------------------------------------------------------
+ // check if the parameters are set - important if one calls this method
+ // directly, not from the Hits2Digits
+
+ if(fDefaults == 0) SetDefaults();
TTree *tH = gAlice->TreeH(); // pointer to the hits tree
Stat_t ntracks = tH->GetEntries();
TObjArray **row;
- //printf("*** Processing sector number %d ***\n",isec);
+ printf("*** Processing sector number %d ***\n",isec);
Int_t nrows =fTPCParam->GetNRow(isec);
for (i=0;i<nrows;i++){
- AliDigits * dig = fDigitsArray->CreateRow(isec,i);
+ AliDigits * dig = fDigitsArray->CreateRow(isec,i);
DigitizeRow(i,isec,row);
Int_t ndig = dig->GetDigitSize();
- //printf("*** Sector, row, compressed digits %d %d %d ***\n",isec,i,ndig);
+ printf("*** Sector, row, compressed digits %d %d %d ***\n",isec,i,ndig);
fDigitsArray->ClearRow(isec,i);
} // end of loop over hits
xxxx->Delete();
-
-
}
+//_______________________________________________________________________________
+void AliTPC::Digits2Reco(Int_t eventnumber)
+{
+ // empty for a time being
+}
class AliTPC : public AliDetector {
protected:
+ Int_t fDefaults;
Int_t fSens; // ISENS
Int_t fSecAL; // Upper sector selector
Int_t fSecAU; // Lower sector selector
virtual void BuildGeometry();
virtual void CreateGeometry() {}
virtual void CreateMaterials();
- virtual void Hits2Clusters(TFile *of);
+ virtual void Hits2Clusters(TFile *of, Int_t eventn);
virtual void Hits2ExactClustersSector(Int_t isec); // MI change calculate "exact" cluster position
- virtual void SDigits2Digits();
- virtual void Hits2SDigits();
- virtual void Hits2Digits(); //MI change
+ virtual void SDigits2Digits(Int_t eventnumber=0);
+ virtual void Hits2SDigits(Int_t eventnumber=0);
+ virtual void Digits2Reco(Int_t eventnumber=0);
+ virtual void Hits2Digits(Int_t eventnumber=0); //MI change
virtual void Hits2DigitsSector(Int_t isec); //MI change
virtual void Init();
virtual Int_t IsVersion() const =0;
- virtual void Digits2Clusters(TFile *of);
+ virtual void Digits2Clusters(TFile *of, Int_t eventnumber=0);
virtual void Clusters2Tracks(TFile *of);
Int_t GetNsectors() {return fNsectors;}
//middle of the row
void SetHitType(Int_t type){fHitType =type;} //set type of hit container
void SetDigitsSwitch(Int_t sw){fDigitsSwitch = sw;}
+ void SetDefSwitch(Int_t def){fDefaults = def;}
private:
//
+ void SetDefaults();
void DigitizeRow(Int_t irow,Int_t isec,TObjArray **rowTriplet);
Float_t GetSignal(TObjArray *p1, Int_t ntr, TMatrix *m1, TMatrix *m2,
Int_t *IndexRange);
// index[2] pad row number
// index[3] pad row number for which signal is calculated
- ClassDef(AliTPC,3) // Time Projection Chamber class
+ ClassDef(AliTPC,4) // Time Projection Chamber class
};
#endif
struct GoodTrack {
+ Int_t fEventN; //event number
Int_t lab;
Int_t code;
Float_t px,py,pz;
Float_t x,y,z;
};
-Int_t good_tracks(GoodTrack *gt, Int_t max);
+Int_t good_tracks(GoodTrack *gt, Int_t max, Int_t eventn=1);
-Int_t AliTPCComparison() {
+Int_t AliTPCComparison(Int_t eventn=1) {
cerr<<"Doing comparison...\n";
Int_t i;
gBenchmark->Start("AliTPCComparison");
if (!cf->IsOpen()) {cerr<<"Can't open AliTPCclusters.root !\n"; return 1;}
AliTPCParam *digp= (AliTPCParam*)cf->Get("75x40_100x60");
if (!digp) { cerr<<"TPC parameters have not been found !\n"; return 2; }
- AliTPCtracker *tracker = new AliTPCtracker(digp);
-// Load clusters
- tracker->LoadInnerSectors();
- tracker->LoadOuterSectors();
-// Load tracks
- TFile *tf=TFile::Open("AliTPCtracks.root");
- if (!tf->IsOpen()) {cerr<<"Can't open AliTPCtracks.root !\n"; return 3;}
+
+ ///////////
+ AliTPCtracker *tracker =0;
TObjArray tarray(2000);
- TTree *tracktree=(TTree*)tf->Get("TPCf");
- if (!tracktree) {cerr<<"Can't get a tree with TPC tracks !\n"; return 4;}
- TBranch *tbranch=tracktree->GetBranch("tracks");
- Int_t nentr=(Int_t)tracktree->GetEntries();
-
AliTPCtrack *iotrack=0;
- for (i=0; i<nentr; i++) {
+ Int_t nentr= 0;
+ Int_t eventptr[1000];
+ TFile *tf=TFile::Open("AliTPCtracks.root");
+ TTree *tracktree=0;
+ // Load clusters
+ eventptr[0]=0;
+ eventptr[1]=0;
+ for (Int_t event=0;event<eventn; event++){
+ cf->cd();
+ tracker = new AliTPCtracker(digp,event);
+ tracker->LoadInnerSectors();
+ tracker->LoadOuterSectors();
+ char tname[100];
+ if (eventn==-1) {
+ sprintf(tname,"TreeT_TPC");
+ }
+ else {
+ sprintf(tname,"TreeT_TPC_%d",event);
+ }
+
+ // Load tracks
+ if (!tf->IsOpen()) {cerr<<"Can't open AliTPCtracks.root !\n"; return 3;}
+ tracktree=(TTree*)tf->Get(tname);
+ if (!tracktree) {cerr<<"Can't get a tree with TPC tracks !\n"; return 4;}
+ TBranch *tbranch=tracktree->GetBranch("tracks");
+ Int_t nentr0=(Int_t)tracktree->GetEntries();
+ nentr+=nentr0;
+ for (i=0; i<nentr0; i++) {
iotrack=new AliTPCtrack;
tbranch->SetAddress(&iotrack);
tracktree->GetEvent(i);
tracker->CookLabel(iotrack,0.1);
tarray.AddLast(iotrack);
- }
-
- delete tracker;
-
+ }
+ eventptr[event+1] = nentr; //store end of the event
+ delete tracker;
+ }
tf->Close();
cf->Close();
+
+ //MI change for a moment
+
/////////////////////////////////////////////////////////////////////////
- GoodTrack gt[15000];
+ // GoodTrack gt[15000];
+ GoodTrack gt[45000];
+
Int_t ngood=0;
ifstream in("good_tracks_tpc");
if (in) {
cerr<<"Reading good tracks...\n";
- while (in>>gt[ngood].lab>>gt[ngood].code>>
+ while (in>>gt[ngood].fEventN>>gt[ngood].lab>>gt[ngood].code>>
gt[ngood].px>>gt[ngood].py>>gt[ngood].pz>>
gt[ngood].x >>gt[ngood].y >>gt[ngood].z) {
ngood++;
cerr<<ngood<<'\r';
- if (ngood==15000) {
+ if (ngood==45000) {
cerr<<"Too many good tracks !\n";
break;
}
if (!in.eof()) cerr<<"Read error (good_tracks_tpc) !\n";
} else {
cerr<<"Marking good tracks (this will take a while)...\n";
- ngood=good_tracks(gt,15000);
+ ngood=good_tracks(gt,45000,eventn); //mi change
ofstream out("good_tracks_tpc");
if (out) {
for (Int_t ngd=0; ngd<ngood; ngd++)
- out<<gt[ngd].lab<<' '<<gt[ngd].code<<' '<<
+ out<<gt[ngd].fEventN<<' '<<gt[ngd].lab<<' '<<gt[ngd].code<<' '<<
gt[ngd].px<<' '<<gt[ngd].py<<' '<<gt[ngd].pz<<' '<<
gt[ngd].x <<' '<<gt[ngd].y <<' '<<gt[ngd].z <<endl;
} else cerr<<"Can not open file (good_tracks_tpc) !\n";
out.close();
+ /*
cerr<<"Preparing tracks for matching with the ITS...\n";
tarray.Sort();
tf=TFile::Open("AliTPCtracks.root","recreate");
}
tracktree->Write();
tf->Close();
+ */
}
cerr<<"Number of good tracks : "<<ngood<<endl;
if (ptg<pmin) continue;
hgood->Fill(ptg);
+ Int_t ievent = gt[ngood].fEventN;
AliTPCtrack *track=0;
- for (i=0; i<nentr; i++) {
+ // for (i=0; i<nentr; i++) {
+ for (i=eventptr[ievent]; i<eventptr[ievent+1]; i++) {
+
track=(AliTPCtrack*)tarray.UncheckedAt(i);
tlab=track->GetLabel();
if (lab==TMath::Abs(tlab)) break;
}
- if (i==nentr) {
+ // if (i==nentr) {
+ if (i==eventptr[ievent+1]) {
+
//cerr<<"Track "<<lab<<" was not found !\n";
track_notfound[itrack_notfound++]=lab;
continue;
Int_t micount=0;
Int_t mi;
AliTPCtrack * mitrack;
- for (mi=0; mi<nentr; mi++) {
+ // for (mi=0; mi<nentr; mi++) {
+ for (mi=eventptr[ievent]; mi<eventptr[ievent+1]; mi++) {
+
mitrack=(AliTPCtrack*)tarray.UncheckedAt(mi);
if (lab==TMath::Abs(mitrack->GetLabel())) micount++;
}
}
-Int_t good_tracks(GoodTrack *gt, Int_t max) {
- Int_t nt=0;
+Int_t good_tracks(GoodTrack *gt, Int_t max, Int_t eventn) {
+ //eventn - number of events in file
TFile *file=TFile::Open("rfio:galice.root");
if (!file->IsOpen()) {cerr<<"Can't open galice.root !\n"; exit(4);}
exit(5);
}
- Int_t np=gAlice->GetEvent(0);
+ // Int_t np=gAlice->GetEvent(0); //MI change
AliTPC *TPC=(AliTPC*)gAlice->GetDetector("TPC");
Int_t ver = TPC->IsVersion();
Int_t gap=Int_t(0.125*nrows);
Int_t good_number=Int_t(0.4*nrows);
- Int_t *good=new Int_t[np];
- for (Int_t ii=0; ii<np; ii++) good[ii]=0;
-
-
- //MI change to be possible compile macro
- //definition out of the swith statemnet
- Int_t sectors_by_rows=0;
- TTree *TD=0;
- AliSimDigits da, *digits=&da;
- Int_t *count=0;
- switch (ver) {
- case 1:
- {
- TFile *cf=TFile::Open("AliTPCclusters.root");
- if (!cf->IsOpen()){cerr<<"Can't open AliTPCclusters.root !\n";exit(5);}
- AliTPCClustersArray *ca=new AliTPCClustersArray;
- ca->Setup(digp);
- ca->SetClusterType("AliTPCcluster");
- ca->ConnectTree("Segment Tree");
- Int_t nrows=Int_t(ca->GetTree()->GetEntries());
- for (Int_t n=0; n<nrows; n++) {
- AliSegmentID *s=ca->LoadEntry(n);
- Int_t sec,row;
- digp->AdjustSectorRow(s->GetID(),sec,row);
- AliTPCClustersRow &clrow = *ca->GetRow(sec,row);
- Int_t ncl=clrow.GetArray()->GetEntriesFast();
- while (ncl--) {
- AliTPCcluster *c=(AliTPCcluster*)clrow[ncl];
- Int_t lab=c->GetLabel(0);
- if (lab<0) continue; //noise cluster
- lab=TMath::Abs(lab);
- if (sec>=digp->GetNInnerSector())
- if (row==nrow_up-1 ) good[lab]|=0x1000;
- if (sec>=digp->GetNInnerSector())
- if (row==nrow_up-1-gap) good[lab]|=0x800;
- good[lab]++;
- }
- ca->ClearRow(sec,row);
- }
- cf->Close();
- }
- break;
- case 2:
- TD=(TTree*)gDirectory->Get("TreeD_75x40_100x60");
- TD->GetBranch("Segment")->SetAddress(&digits);
- count = new Int_t[np];
- Int_t i;
- for (i=0; i<np; i++) count[i]=0;
- sectors_by_rows=(Int_t)TD->GetEntries();
- for (i=0; i<sectors_by_rows; i++) {
- if (!TD->GetEvent(i)) continue;
- Int_t sec,row;
- digp->AdjustSectorRow(digits->GetID(),sec,row);
- cerr<<sec<<' '<<row<<" \r";
- digits->First();
- do { //Many thanks to J.Chudoba who noticed this
- Int_t it=digits->CurrentRow(), ip=digits->CurrentColumn();
- Short_t dig = digits->GetDigit(it,ip);
- Int_t idx0=digits->GetTrackID(it,ip,0);
- Int_t idx1=digits->GetTrackID(it,ip,1);
- Int_t idx2=digits->GetTrackID(it,ip,2);
- if (idx0>=0 && dig>=zero) count[idx0]+=1;
- if (idx1>=0 && dig>=zero) count[idx1]+=1;
- if (idx2>=0 && dig>=zero) count[idx2]+=1;
- } while (digits->Next());
- for (Int_t j=0; j<np; j++) {
- if (count[j]>1) {
- if (sec>=digp->GetNInnerSector())
- if (row==nrow_up-1 ) good[j]|=0x1000;
- if (sec>=digp->GetNInnerSector())
- if (row==nrow_up-1-gap) good[j]|=0x800;
- good[j]++;
- }
- count[j]=0;
- }
- }
- delete[] count;
- break;
- default:
- cerr<<"Invalid TPC version !\n";
- file->Close();
- exit(7);
- }
-
- TTree *TH=gAlice->TreeH();
- Int_t npart=(Int_t)TH->GetEntries();
- while (npart--) {
- AliTPChit *hit0=0;
-
- TPC->ResetHits();
- TH->GetEvent(npart);
- AliTPChit * hit = (AliTPChit*) TPC->FirstHit(-1);
- while (hit){
- if (hit->fQ==0.) break;
+ //MI change
+ Int_t nt=0; //reset counter
+ char treeName[100]; //declare event identifier
+
+ for (Int_t event=0;event<eventn;event++){
+
+ Int_t np=gAlice->GetEvent(event);
+ Int_t *good=new Int_t[np];
+ for (Int_t ii=0; ii<np; ii++) good[ii]=0;
+
+
+ //MI change to be possible compile macro
+ //definition out of the swith statemnet
+ Int_t sectors_by_rows=0;
+ TTree *TD=0;
+ AliSimDigits da, *digits=&da;
+ Int_t *count=0;
+ switch (ver) {
+ case 1:
+ {
+ TFile *cf=TFile::Open("AliTPCclusters.root");
+ if (!cf->IsOpen()){cerr<<"Can't open AliTPCclusters.root !\n";exit(5);}
+ AliTPCClustersArray *ca=new AliTPCClustersArray;
+ ca->Setup(digp);
+ ca->SetClusterType("AliTPCcluster");
+ ca->ConnectTree("Segment Tree");
+ Int_t nrows=Int_t(ca->GetTree()->GetEntries());
+ for (Int_t n=0; n<nrows; n++) {
+ AliSegmentID *s=ca->LoadEntry(n);
+ Int_t sec,row;
+ digp->AdjustSectorRow(s->GetID(),sec,row);
+ AliTPCClustersRow &clrow = *ca->GetRow(sec,row);
+ Int_t ncl=clrow.GetArray()->GetEntriesFast();
+ while (ncl--) {
+ AliTPCcluster *c=(AliTPCcluster*)clrow[ncl];
+ Int_t lab=c->GetLabel(0);
+ if (lab<0) continue; //noise cluster
+ lab=TMath::Abs(lab);
+ if (sec>=digp->GetNInnerSector())
+ if (row==nrow_up-1 ) good[lab]|=0x1000;
+ if (sec>=digp->GetNInnerSector())
+ if (row==nrow_up-1-gap) good[lab]|=0x800;
+ good[lab]++;
+ }
+ ca->ClearRow(sec,row);
+ }
+ cf->Close();
+ }
+ break;
+ case 2:
+
+ sprintf(treeName,"TreeD_75x40_100x60_%d",event);
+ TD=(TTree*)gDirectory->Get(treeName);
+ TD->GetBranch("Segment")->SetAddress(&digits);
+ count = new Int_t[np];
+ Int_t i;
+ for (i=0; i<np; i++) count[i]=0;
+ sectors_by_rows=(Int_t)TD->GetEntries();
+ for (i=0; i<sectors_by_rows; i++) {
+ if (!TD->GetEvent(i)) continue;
+ Int_t sec,row;
+ digp->AdjustSectorRow(digits->GetID(),sec,row);
+ cerr<<sec<<' '<<row<<" \r";
+ digits->First();
+ do { //Many thanks to J.Chudoba who noticed this
+ Int_t it=digits->CurrentRow(), ip=digits->CurrentColumn();
+ Short_t dig = digits->GetDigit(it,ip);
+ Int_t idx0=digits->GetTrackID(it,ip,0);
+ Int_t idx1=digits->GetTrackID(it,ip,1);
+ Int_t idx2=digits->GetTrackID(it,ip,2);
+ if (idx0>=0 && dig>=zero) count[idx0]+=1;
+ if (idx1>=0 && dig>=zero) count[idx1]+=1;
+ if (idx2>=0 && dig>=zero) count[idx2]+=1;
+ } while (digits->Next());
+ for (Int_t j=0; j<np; j++) {
+ if (count[j]>1) {
+ if (sec>=digp->GetNInnerSector())
+ if (row==nrow_up-1 ) good[j]|=0x1000;
+ if (sec>=digp->GetNInnerSector())
+ if (row==nrow_up-1-gap) good[j]|=0x800;
+ good[j]++;
+ }
+ count[j]=0;
+ }
+ }
+ delete[] count;
+ break;
+ default:
+ cerr<<"Invalid TPC version !\n";
+ file->Close();
+ exit(7);
+ }
+
+ TTree *TH=gAlice->TreeH();
+ Int_t npart=(Int_t)TH->GetEntries();
+
+ while (npart--) {
+ AliTPChit *hit0=0;
+
+ TPC->ResetHits();
+ TH->GetEvent(npart);
+ AliTPChit * hit = (AliTPChit*) TPC->FirstHit(-1);
+ while (hit){
+ if (hit->fQ==0.) break;
hit = (AliTPChit*) TPC->NextHit();
- }
- if (hit) {
- hit0 = new AliTPChit(*hit); //Make copy of hit
- hit = hit0;
- }
- else continue;
- AliTPChit *hit1=(AliTPChit*)TPC->NextHit();
- if (hit1==0) continue;
- if (hit1->fQ != 0.) continue;
- Int_t i=hit->Track();
- TParticle *p = (TParticle*)gAlice->Particle(i);
-
- if (p->GetFirstMother()>=0) continue; //secondary particle
- if (good[i] < 0x1000+0x800+2+good_number) continue;
- if (p->Pt()<0.100) continue;
- if (TMath::Abs(p->Pz()/p->Pt())>0.999) continue;
-
- gt[nt].lab=i;
- gt[nt].code=p->GetPdgCode();
-//**** px py pz - in global coordinate system, x y z - in local !
- gt[nt].px=hit->X(); gt[nt].py=hit->Y(); gt[nt].pz=hit->Z();
- Float_t cs,sn; digp->AdjustCosSin(hit1->fSector,cs,sn);
- gt[nt].x = hit1->X()*cs + hit1->Y()*sn;
- gt[nt].y =-hit1->X()*sn + hit1->Y()*cs;
- gt[nt].z = hit1->Z();
- nt++;
- if (hit0) delete hit0;
- cerr<<i<<" \r";
- if (nt==max) {cerr<<"Too many good tracks !\n"; break;}
+ }
+ if (hit) {
+ hit0 = new AliTPChit(*hit); //Make copy of hit
+ hit = hit0;
+ }
+ else continue;
+ AliTPChit *hit1=(AliTPChit*)TPC->NextHit();
+ if (hit1==0) continue;
+ if (hit1->fQ != 0.) continue;
+ Int_t i=hit->Track();
+ TParticle *p = (TParticle*)gAlice->Particle(i);
+
+ if (p->GetFirstMother()>=0) continue; //secondary particle
+ if (good[i] < 0x1000+0x800+2+good_number) continue;
+ if (p->Pt()<0.100) continue;
+ if (TMath::Abs(p->Pz()/p->Pt())>0.999) continue;
+
+ gt[nt].lab=i;
+ gt[nt].code=p->GetPdgCode();
+ //**** px py pz - in global coordinate system, x y z - in local !
+ gt[nt].px=hit->X(); gt[nt].py=hit->Y(); gt[nt].pz=hit->Z();
+ Float_t cs,sn; digp->AdjustCosSin(hit1->fSector,cs,sn);
+ gt[nt].fEventN=event; //MI change
+ gt[nt].x = hit1->X()*cs + hit1->Y()*sn;
+ gt[nt].y =-hit1->X()*sn + hit1->Y()*cs;
+ gt[nt].z = hit1->Z();
+ nt++;
+ if (hit0) delete hit0;
+ cerr<<i<<" \r";
+ if (nt==max) {cerr<<"Too many good tracks !\n"; break;}
+ }
+ delete[] good;
}
- delete[] good;
-
delete gAlice; gAlice=0;
file->Close();
-Int_t AliTPCDisplayClusters() {
+Int_t AliTPCDisplayClusters(Int_t eventn) {
cerr<<"Displaying clusters...\n";
- TFile *file=TFile::Open("rfio:galice.root");
+ TFile *file=TFile::Open("galice.root");
if (!file->IsOpen()) {cerr<<"Can't open galice.root !\n"; return 1;}
TFile *cf=TFile::Open("AliTPCclusters.root");
AliTPCClustersArray *ca=new AliTPCClustersArray;
ca->Setup(dig);
ca->SetClusterType("AliTPCcluster");
- ca->ConnectTree("Segment Tree");
+ char cname[100];
+ sprintf(cname,"TreeC_TPC_%d",eventn);
+
+ ca->ConnectTree(cname);
Int_t nrows=Int_t(ca->GetTree()->GetEntries());
for (Int_t n=0; n<nrows; n++) {
AliSegmentID *s=ca->LoadEntry(n);
#include "TStopwatch.h"
#endif
-Int_t AliTPCFindClusters() {
+Int_t AliTPCFindClusters(Int_t n) {
TFile *out=TFile::Open("AliTPCclusters.root","new");
if (!out->IsOpen()) {cerr<<"Delete old AliTPCclusters.root !\n"; return 1;}
TFile *in=TFile::Open("rfio:galice.root");
TDirectory *cwd = gDirectory;
- gAlice->GetEvent(0);
-
AliTPC *TPC = (AliTPC*)gAlice->GetDetector("TPC");
Int_t ver = TPC->IsVersion();
cerr<<"TPC version "<<ver<<" has been found !\n";
cerr<<"Making clusters...\n";
{
AliTPCv1 &tpc=*((AliTPCv1*)TPC);
- tpc.SetParam(dig); timer.Start(); cwd->cd(); tpc.Hits2Clusters(out);
+ tpc.SetParam(dig); timer.Start(); cwd->cd();
+ for(Int_t i=0;i<n;i++){
+ printf("Processing event %d\n",i);
+ gAlice->GetEvent(i);
+ tpc.Hits2Clusters(out,i);
+ }
}
break;
case 2:
cerr<<"Looking for clusters...\n";
{
- delete gAlice; gAlice=0;
+ // delete gAlice; gAlice=0;
AliTPCv2 tpc;
- tpc.SetParam(dig); timer.Start(); cwd->cd(); tpc.Digits2Clusters(out);
+ tpc.SetParam(dig); timer.Start(); cwd->cd();
+ for (Int_t i=0;i<n;i++){
+ printf("Processing event %d\n",i);
+ tpc.Digits2Clusters(out,i);
+ // AliTPCclusterer::Digits2Clusters(dig, out, i);
+ }
}
break;
default:
#include "TStopwatch.h"
#endif
-Int_t AliTPCFindTracks() {
+Int_t AliTPCFindTracks(Int_t eventn=1) {
cerr<<"Looking for tracks...\n";
TFile *out=TFile::Open("AliTPCtracks.root","new");
if (!par) {cerr<<"Can't get TPC parameters !\n"; return 3;}
TStopwatch timer;
- AliTPCtracker *tracker = new AliTPCtracker(par);
- Int_t rc=tracker->Clusters2Tracks(0,out);
+
+ for (Int_t i=0;i<eventn;i++){
+ printf("Processing event %d\n",i);
+ AliTPCtracker *tracker = new AliTPCtracker(par,i);
+ Int_t rc=tracker->Clusters2Tracks(0,out);
+ }
delete tracker;
timer.Stop(); timer.Print();
in->Close();
out->Close();
- return rc;
+ return 1;
}
-Int_t AliTPCHits2Digits()
+Int_t AliTPCHits2Digits(Int_t nevent=1)
{
// new version by J.Belikov
return 2;
}
- gAlice->GetEvent(0);
- AliTPC *TPC = (AliTPC*)gAlice->GetDetector("TPC");
-
-//Set response functions
-
- AliTPCParamSR *param=(AliTPCParamSR*)gDirectory->Get("75x40_100x60");
- AliTPCPRF2D * prfinner = new AliTPCPRF2D;
- AliTPCPRF2D * prfouter = new AliTPCPRF2D;
- AliTPCRF1D * rf = new AliTPCRF1D(kTRUE);
- rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
- rf->SetOffset(3*param->GetZSigma());
- rf->Update();
-
- TDirectory *savedir=gDirectory;
- TFile *f=TFile::Open("$ALICE_ROOT/TPC/AliTPCprf2d.root");
- if (!f->IsOpen()) {
- cerr<<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !\n"
- return 3;
- }
- prfinner->Read("prf_07504_Gati_056068_d02");
- prfouter->Read("prf_10006_Gati_047051_d03");
- f->Close();
- savedir->cd();
- param->SetInnerPRF(prfinner);
- param->SetOuterPRF(prfouter);
- param->SetTimeRF(rf);
- TPC->SetParam(param);
-
- cerr<<"Digitizing TPC...\n";
- //setup TPCDigitsArray
- AliTPCDigitsArray *arr = new AliTPCDigitsArray;
- arr->SetClass("AliSimDigits");
- arr->Setup(param);
- TPC->SetParam(param);
- arr->MakeTree();
+ // gAlice->GetEvent(0);
+ AliTPC *TPC = (AliTPC*)gAlice->GetDetector("TPC");
- TPC->SetDigitsArray(arr);
- TPC->Hits2Digits();
- /* TPC->Hits2DigitsSector(1);
- TPC->Hits2DigitsSector(2);
- TPC->Hits2DigitsSector(3);
- TPC->Hits2DigitsSector(1+18);
- TPC->Hits2DigitsSector(2+18);
- TPC->Hits2DigitsSector(3+18);
+ TStopwatch timer;
+ timer.Start();
- TPC->Hits2DigitsSector(36+1);
- TPC->Hits2DigitsSector(36+2);
- TPC->Hits2DigitsSector(36+3);
- TPC->Hits2DigitsSector(36+1+18);
- TPC->Hits2DigitsSector(36+2+18);
- TPC->Hits2DigitsSector(36+3+18); */
-
- //write results
+ for(Int_t eventn =0;eventn<nevent;eventn++){
+ printf("Processing event %d",eventn);
+ gAlice->GetEvent(eventn);
- char treeName[100];
- sprintf(treeName,"TreeD_%s",param->GetTitle());
- TPC->GetDigitsArray()->GetTree()->Write(treeName);
+ TPC->Hits2Digits(eventn);
+ }
delete gAlice; gAlice=0;
file->Close(); delete file;
+ timer.Stop();
+ timer.Print();
+
return 0;
};
/*
$Log$
+Revision 1.4 2001/04/17 08:06:27 hristov
+Possibility to define the magnetic field in the reconstruction (Yu.Belikov)
+
Revision 1.3 2000/10/05 16:14:01 kowal2
Forward declarations.
}
//_____________________________________________________________________________
-void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of)
+void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of, Int_t eventn)
{
//-----------------------------------------------------------------
// This is a simple cluster finder.
const Int_t kMAXZ=par->GetMaxTBin()+2;
- TTree *t = (TTree *)gDirectory->Get("TreeD_75x40_100x60");
+ char dname[100];
+ char cname[100];
+ if (eventn==-1) {
+
+ // for backward compatibility
+
+ sprintf(dname,"TreeD_75x40_100x60");
+ sprintf(cname,"TreeC_TPC");
+ }
+ else {
+ sprintf(dname,"TreeD_75x40_100x60_%d",eventn);
+ sprintf(cname,"TreeC_TPC_%d",eventn);
+ }
+ TTree *t = (TTree *)gDirectory->Get(dname);
+
AliSimDigits digarr, *dummy=&digarr;
t->GetBranch("Segment")->SetAddress(&dummy);
Stat_t nentries = t->GetEntries();
carray.SetClusterType("AliTPCcluster");
carray.MakeTree();
+
+
Int_t nclusters=0;
for (Int_t n=0; n<nentries; n++) {
cerr<<"Number of found clusters : "<<nclusters<<" \n";
- carray.GetTree()->Write();
+ carray.GetTree()->Write(cname);
savedir->cd();
}
class AliTPCclusterer {
public:
- static void Digits2Clusters(const AliTPCParam *par, TFile *of);
+ static void Digits2Clusters(const AliTPCParam *par, TFile *of, Int_t eventn=1);
private:
class AliBin {
/*
$Log$
+Revision 1.11 2001/05/23 08:50:10 hristov
+Weird inline removed
+
Revision 1.10 2001/05/16 14:57:25 alibrary
New files for folders and Stack
#include "AliTPCParam.h"
#include "AliTPCClustersRow.h"
+
+AliTPCtracker::AliTPCtracker(const AliTPCParam *par)
+{;
+//MI change only provisore - need change in the ITS code which depend on it
+}
+
+
//_____________________________________________________________________________
-AliTPCtracker::AliTPCtracker(const AliTPCParam *par):
+AliTPCtracker::AliTPCtracker(const AliTPCParam *par, Int_t eventn):
fkNIS(par->GetNInnerSector()/2),
fkNOS(par->GetNOuterSector()/2)
{
fClustersArray.Setup(par);
fClustersArray.SetClusterType("AliTPCcluster");
- fClustersArray.ConnectTree("Segment Tree");
+ char cname[100];
+ if (eventn==-1) {
+ sprintf(cname,"TreeC_TPC");
+ }
+ else {
+ sprintf(cname,"TreeC_TPC_%d",eventn);
+ }
+
+ fClustersArray.ConnectTree(cname);
+
+ fEventN = eventn;
fSeeds=0;
}
}
UnloadInnerSectors();
- tracktree.Write();
+ char tname[100];
+ if (fEventN==-1) {
+ sprintf(tname,"TreeT_TPC");
+ }
+ else {
+ sprintf(tname,"TreeT_TPC_%d",fEventN);
+ }
+
+
+ tracktree.Write(tname);
cerr<<"Number of found tracks : "<<found<<endl;
class AliTPCtracker : public AliTracker {
public:
AliTPCtracker():AliTracker(),fkNIS(0),fkNOS(0) {}
- AliTPCtracker(const AliTPCParam *par);
+ AliTPCtracker(const AliTPCParam *par, Int_t eventn);
+ AliTPCtracker(const AliTPCParam *par);
~AliTPCtracker();
Int_t ReadSeeds(const TFile *in);
Double_t fAlpha; //opening angle
Double_t fAlphaShift; //shift angle;
Double_t fPadPitchWidth; //pad pitch width
- Double_t fPadPitchLength; //pad pitch length
-
+ Double_t fPadPitchLength; //pad pitch length
private:
AliTPCSector(const AliTPCSector &s); //dummy copy contructor
AliTPCSector& operator=(const AliTPCSector &s);//dummy assignment operator
Int_t fN; //number of loaded sectors
AliTPCSector *fSectors; //pointer to loaded sectors;
+ Int_t fEventN; //event number
AliTPCClustersArray fClustersArray; //array of TPC clusters
TObjArray *fSeeds; //array of track seeds
};
#pragma link C++ class AliHitInfo+;
+#pragma link C++ class AliTPCclusterer-;
+
+
+
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff