/*
$Log$
+Revision 1.52 2002/02/18 09:26:09 kowal2
+Removed compiler warning
+
+Revision 1.51 2002/01/21 17:13:21 kowal2
+New track hits using root containers. Setting active sectors added.
+
+Revision 1.50 2001/12/06 14:16:19 kowal2
+meaningfull printouts
+
+Revision 1.49 2001/11/30 11:55:37 hristov
+Noise table created in Hits2SDigits (M.Ivanov)
+
+Revision 1.48 2001/11/24 16:10:21 kowal2
+Faster algorithms.
+
+Revision 1.47 2001/11/19 10:25:34 kowal2
+Nearest integer instead of integer when converting to ADC counts
+
+Revision 1.46 2001/11/07 06:47:12 kowal2
+Removed printouts
+
+Revision 1.45 2001/11/03 13:33:48 kowal2
+Updated algorithms in Hits2SDigits, SDigits2Digits,
+Hits2ExactClusters.
+Added method Merge
+
+Revision 1.44 2001/08/30 09:28:48 hristov
+TTree names are explicitly set via SetName(name) and then Write() is called
+
+Revision 1.43 2001/07/28 12:02:54 hristov
+Branch split level set to 99
+
+Revision 1.42 2001/07/28 11:38:52 hristov
+Loop variable declared once
+
+Revision 1.41 2001/07/28 10:53:50 hristov
+Digitisation done according to the general scheme (M.Ivanov)
+
+Revision 1.40 2001/07/27 13:03:14 hristov
+Default Branch split level set to 99
+
+Revision 1.39 2001/07/26 09:09:34 kowal2
+Hits2Reco method added
+
+Revision 1.38 2001/07/20 14:32:43 kowal2
+Processing of many events possible now
+
+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
+
Revision 1.35 2001/05/08 16:02:22 kowal2
Updated material specifications
#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>
#include "AliDigits.h"
#include "AliSimDigits.h"
#include "AliTPCTrackHits.h"
+#include "AliTPCTrackHitsV2.h"
#include "AliPoints.h"
#include "AliArrayBranch.h"
ClassImp(AliTPC)
+//_____________________________________________________________________________
+// helper class for fast matrix and vector manipulation - no range checking
+// origin - Marian Ivanov
+
+class AliTPCFastMatrix : public TMatrix {
+public :
+ AliTPCFastMatrix(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb);
+ inline Float_t & UncheckedAt(Int_t rown, Int_t coln) const {return (fIndex[coln])[rown];} //fast acces
+ inline Float_t UncheckedAtFast(Int_t rown, Int_t coln) const {return (fIndex[coln])[rown];} //fast acces
+};
+
+AliTPCFastMatrix::AliTPCFastMatrix(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb):
+ TMatrix(row_lwb, row_upb,col_lwb,col_upb)
+ {
+ };
+//_____________________________________________________________________________
+class AliTPCFastVector : public TVector {
+public :
+ AliTPCFastVector(Int_t size);
+ inline Float_t & UncheckedAt(Int_t index) const {return fElements[index];} //fast acces
+};
+
+AliTPCFastVector::AliTPCFastVector(Int_t size):TVector(size){
+};
+
//_____________________________________________________________________________
AliTPC::AliTPC()
{
fHits = 0;
fDigits = 0;
fNsectors = 0;
- //MI changes
fDigitsArray = 0;
fClustersArray = 0;
- fTPCParam=0;
- fTrackHits = 0;
- fHitType = 2;
- fTPCParam = 0;
+ fDefaults = 0;
+ fTrackHits = 0;
+ fTrackHitsOld = 0;
+ fHitType = 4; //default CONTAINERS - based on ROOT structure
+ fTPCParam = 0;
+ fNoiseTable = 0;
+ fActiveSectors =0;
+
}
//_____________________________________________________________________________
//
// Initialise arrays of hits and digits
fHits = new TClonesArray("AliTPChit", 176);
- gAlice->AddHitList(fHits);
- //MI change
+ gAlice->AddHitList(fHits);
fDigitsArray = 0;
fClustersArray= 0;
+ fDefaults = 0;
//
- fTrackHits = new AliTPCTrackHits; //MI - 13.09.2000
+ fTrackHits = new AliTPCTrackHitsV2;
fTrackHits->SetHitPrecision(0.002);
fTrackHits->SetStepPrecision(0.003);
- fTrackHits->SetMaxDistance(100);
+ fTrackHits->SetMaxDistance(100);
- fHitType = 2;
+ fTrackHitsOld = new AliTPCTrackHits; //MI - 13.09.2000
+ fTrackHitsOld->SetHitPrecision(0.002);
+ fTrackHitsOld->SetStepPrecision(0.003);
+ fTrackHitsOld->SetMaxDistance(100);
+
+ fNoiseTable =0;
+
+ fHitType = 4;
+ fActiveSectors = 0;
//
// Initialise counters
fNsectors = 0;
// 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;
delete fDigits;
delete fTPCParam;
delete fTrackHits; //MI 15.09.2000
+ delete fTrackHitsOld; //MI 10.12.2001
+ if (fNoiseTable) delete [] fNoiseTable;
+
}
//_____________________________________________________________________________
TClonesArray &lhits = *fHits;
new(lhits[fNhits++]) AliTPChit(fIshunt,track,vol,hits);
}
- if (fHitType&2)
+ if (fHitType>1)
AddHit2(track,vol,hits);
}
}
+void AliTPC::GenerNoise(Int_t tablesize)
+{
+ //
+ //Generate table with noise
+ //
+ if (fTPCParam==0) {
+ // error message
+ fNoiseDepth=0;
+ return;
+ }
+ if (fNoiseTable) delete[] fNoiseTable;
+ fNoiseTable = new Float_t[tablesize];
+ fNoiseDepth = tablesize;
+ fCurrentNoise =0; //!index of the noise in the noise table
+
+ Float_t norm = fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac();
+ for (Int_t i=0;i<tablesize;i++) fNoiseTable[i]= gRandom->Gaus(0,norm);
+}
+
+Float_t AliTPC::GetNoise()
+{
+ // get noise from table
+ // if ((fCurrentNoise%10)==0)
+ // fCurrentNoise= gRandom->Rndm()*fNoiseDepth;
+ if (fCurrentNoise>=fNoiseDepth) fCurrentNoise=0;
+ return fNoiseTable[fCurrentNoise++];
+ //gRandom->Gaus(0, fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac());
+}
+
+
+Bool_t AliTPC::IsSectorActive(Int_t sec)
+{
+ //
+ // check if the sector is active
+ if (!fActiveSectors) return kTRUE;
+ else return fActiveSectors[sec];
+}
+
+void AliTPC::SetActiveSectors(Int_t * sectors, Int_t n)
+{
+ // activate interesting sectors
+ if (fActiveSectors) delete [] fActiveSectors;
+ fActiveSectors = new Bool_t[fTPCParam->GetNSector()];
+ for (Int_t i=0;i<fTPCParam->GetNSector();i++) fActiveSectors[i]=kFALSE;
+ for (Int_t i=0;i<n;i++)
+ if ((sectors[i]>=0) && sectors[i]<fTPCParam->GetNSector()) fActiveSectors[sectors[i]]=kTRUE;
+
+}
+
+void AliTPC::SetActiveSectors()
+{
+ //
+ // activate sectors which were hitted by tracks
+ //loop over tracks
+ if (fHitType==0) return; // if Clones hit - not short volume ID information
+ if (fActiveSectors) delete [] fActiveSectors;
+ fActiveSectors = new Bool_t[fTPCParam->GetNSector()];
+ for (Int_t i=0;i<fTPCParam->GetNSector();i++) fActiveSectors[i]=kFALSE;
+ TBranch * branch=0;
+ if (fHitType>1) branch = gAlice->TreeH()->GetBranch("TPC2");
+ else branch = gAlice->TreeH()->GetBranch("TPC");
+ Stat_t ntracks = gAlice->TreeH()->GetEntries();
+ // loop over all hits
+ for(Int_t track=0;track<ntracks;track++){
+ ResetHits();
+ //
+ if (fTrackHits && fHitType&4) {
+ TBranch * br1 = gAlice->TreeH()->GetBranch("fVolumes");
+ TBranch * br2 = gAlice->TreeH()->GetBranch("fNVolumes");
+ br1->GetEvent(track);
+ br2->GetEvent(track);
+ Int_t *volumes = fTrackHits->GetVolumes();
+ for (Int_t j=0;j<fTrackHits->GetNVolumes(); j++)
+ fActiveSectors[volumes[j]]=kTRUE;
+ }
+
+ //
+ if (fTrackHitsOld && fHitType&2) {
+ TBranch * br = gAlice->TreeH()->GetBranch("fTrackHitsInfo");
+ br->GetEvent(track);
+ AliObjectArray * ar = fTrackHitsOld->fTrackHitsInfo;
+ for (UInt_t j=0;j<ar->GetSize();j++){
+ fActiveSectors[((AliTrackHitsInfo*)ar->At(j))->fVolumeID] =kTRUE;
+ }
+ }
+ }
+
+}
+
-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);
tH->GetEvent(track);
//
// Get number of the TPC hits
- //
- // nhits=fHits->GetEntriesFast();
- //
-
+ //
tpcHit = (AliTPChit*)FirstHit(-1);
// Loop over hits
//
- // for(Int_t hit=0;hit<nhits;hit++){
- //tpcHit=(AliTPChit*)fHits->UncheckedAt(hit);
-
while(tpcHit){
if (tpcHit->fQ == 0.) {
}
sector=tpcHit->fSector; // sector number
-
- // if(sector != isec) continue; //terminate iteration
-
if(sector != isec){
tpcHit = (AliTPChit*) NextHit();
continue;
} // end of loop over sectors
cerr<<"Number of made clusters : "<<nclusters<<" \n";
-
+ carray.GetTree()->SetName(cname);
carray.GetTree()->Write();
savedir->cd(); //switch back to the input file
//
TParticle *particle; // pointer to a given particle
AliTPChit *tpcHit; // pointer to a sigle TPC hit
- Int_t sector,nhits;
+ // Int_t sector,nhits;
Int_t ipart;
const Int_t kcmaxhits=30000;
- TVector * xxxx = new TVector(kcmaxhits*4);
- TVector & xxx = *xxxx;
+ AliTPCFastVector * xxxx = new AliTPCFastVector(kcmaxhits*4);
+ AliTPCFastVector & xxx = *xxxx;
Int_t maxhits = kcmaxhits;
//construct array for each padrow
for (Int_t i=0; i<fTPCParam->GetNRow(isec);i++)
TTree *tH = gAlice->TreeH();
Stat_t ntracks = tH->GetEntries();
Int_t npart = gAlice->GetNtrack();
-
+ //MI change
+ TBranch * branch=0;
+ if (fHitType>1) branch = tH->GetBranch("TPC2");
+ else branch = tH->GetBranch("TPC");
+
//------------------------------------------------------------
// Loop over tracks
//------------------------------------------------------------
-
- for(Int_t track=0;track<ntracks;track++){
+
+ for(Int_t track=0;track<ntracks;track++){
+ Bool_t isInSector=kTRUE;
ResetHits();
- tH->GetEvent(track);
+ isInSector = TrackInVolume(isec,track);
+ if (!isInSector) continue;
+ //MI change
+ branch->GetEntry(track); // get next track
//
// Get number of the TPC hits and a pointer
// to the particles
- //
- nhits=fHits->GetEntriesFast();
- //
// Loop over hits
//
Int_t currentIndex=0;
Int_t lastrow=-1; //last writen row
- for(Int_t hit=0;hit<nhits;hit++){
- tpcHit=(AliTPChit*)fHits->UncheckedAt(hit);
- if (tpcHit==0) continue;
- sector=tpcHit->fSector; // sector number
- if(sector != isec) continue;
+
+ //M.I. changes
+
+ tpcHit = (AliTPChit*)FirstHit(-1);
+ while(tpcHit){
+
+ Int_t sector=tpcHit->fSector; // sector number
+ if(sector != isec){
+ tpcHit = (AliTPChit*) NextHit();
+ continue;
+ }
+
ipart=tpcHit->Track();
if (ipart<npart) particle=gAlice->Particle(ipart);
Float_t x[3]={tpcHit->X(),tpcHit->Y(),tpcHit->Z()};
Int_t index[3]={1,isec,0};
Int_t currentrow = fTPCParam->GetPadRow(x,index) ;
- if (currentrow<0) continue;
+ if (currentrow<0) {tpcHit = (AliTPChit*)NextHit(); continue;}
if (lastrow<0) lastrow=currentrow;
if (currentrow==lastrow){
if ( currentIndex>=maxhits){
Float_t bz=detbz/det; //z angle
sumy/=Float_t(currentIndex);
sumz/=Float_t(currentIndex);
- AliComplexCluster cl;
- cl.fX=z;
- cl.fY=y;
- cl.fQ=sumq;
- cl.fSigmaX2=bz;
- cl.fSigmaY2=by;
- cl.fTracks[0]=ipart;
-
+
AliTPCClustersRow * row = (fClustersArray->GetRow(isec,lastrow));
- if (row!=0) row->InsertCluster(&cl);
+ if (row!=0) {
+ AliComplexCluster* cl = new((AliComplexCluster*)row->Append()) AliComplexCluster ;
+ // AliComplexCluster cl;
+ cl->fX=z;
+ cl->fY=y;
+ cl->fQ=sumq;
+ cl->fSigmaX2=bz;
+ cl->fSigmaY2=by;
+ cl->fTracks[0]=ipart;
+ }
currentIndex=0;
lastrow=currentrow;
} //end of calculating cluster for given row
-
+ tpcHit = (AliTPChit*)NextHit();
} // end of loop over hits
} // end of loop over tracks
//write padrows to tree
xxxx->Delete();
}
-//___________________________________________
-void AliTPC::SDigits2Digits()
+
+
+
+//__
+void AliTPC::SDigits2Digits2(Int_t eventnumber)
+{
+ //create digits from summable digits
+ GenerNoise(500000); //create teble with noise
+ char sname[100];
+ char dname[100];
+ sprintf(sname,"TreeS_%s_%d",fTPCParam->GetTitle(),eventnumber);
+ sprintf(dname,"TreeD_%s_%d",fTPCParam->GetTitle(),eventnumber);
+
+ //conect tree with sSDigits
+ TTree *t = (TTree *)gDirectory->Get(sname);
+ AliSimDigits digarr, *dummy=&digarr;
+ t->GetBranch("Segment")->SetAddress(&dummy);
+ Stat_t nentries = t->GetEntries();
+
+ // set zero suppression
+
+ fTPCParam->SetZeroSup(2);
+
+ // get zero suppression
+
+ Int_t zerosup = fTPCParam->GetZeroSup();
+
+ //make tree with digits
+
+ AliTPCDigitsArray *arr = new AliTPCDigitsArray;
+ arr->SetClass("AliSimDigits");
+ arr->Setup(fTPCParam);
+ arr->MakeTree(fDigitsFile);
+
+ AliTPCParam * par =fTPCParam;
+
+ //Loop over segments of the TPC
+
+ for (Int_t n=0; n<nentries; n++) {
+ t->GetEvent(n);
+ Int_t sec, row;
+ if (!par->AdjustSectorRow(digarr.GetID(),sec,row)) {
+ cerr<<"AliTPC warning: invalid segment ID ! "<<digarr.GetID()<<endl;
+ continue;
+ }
+ if (!IsSectorActive(sec)) continue;
+ AliSimDigits * digrow =(AliSimDigits*) arr->CreateRow(sec,row);
+ Int_t nrows = digrow->GetNRows();
+ Int_t ncols = digrow->GetNCols();
+
+ digrow->ExpandBuffer();
+ digarr.ExpandBuffer();
+ digrow->ExpandTrackBuffer();
+ digarr.ExpandTrackBuffer();
+
+
+ Short_t * pamp0 = digarr.GetDigits();
+ Int_t * ptracks0 = digarr.GetTracks();
+ Short_t * pamp1 = digrow->GetDigits();
+ Int_t * ptracks1 = digrow->GetTracks();
+ Int_t nelems =nrows*ncols;
+ Int_t saturation = fTPCParam->GetADCSat();
+ //use internal structure of the AliDigits - for speed reason
+ //if you cahnge implementation
+ //of the Alidigits - it must be rewriten -
+ for (Int_t i= 0; i<nelems; i++){
+ // Float_t q = *pamp0;
+ //q/=16.; //conversion faktor
+ //Float_t noise= GetNoise();
+ //q+=noise;
+ //q= TMath::Nint(q);
+ Float_t q = TMath::Nint(Float_t(*pamp0)/16.+GetNoise());
+ if (q>zerosup){
+ if (q>saturation) q=saturation;
+ *pamp1=(Short_t)q;
+ //if (ptracks0[0]==0)
+ // ptracks1[0]=1;
+ //else
+ ptracks1[0]=ptracks0[0];
+ ptracks1[nelems]=ptracks0[nelems];
+ ptracks1[2*nelems]=ptracks0[2*nelems];
+ }
+ pamp0++;
+ pamp1++;
+ ptracks0++;
+ ptracks1++;
+ }
+
+ arr->StoreRow(sec,row);
+ arr->ClearRow(sec,row);
+ // cerr<<sec<<"\t"<<row<<"\n";
+ }
+
+
+ //write results
+
+
+ arr->GetTree()->SetName(dname);
+ arr->GetTree()->Write();
+ delete arr;
+}
+//_________________________________________
+void AliTPC::Merge(TTree * intree, Int_t *mask, Int_t nin, Int_t outid)
{
+
+ //intree - pointer to array of trees with s digits
+ //mask - mask for each
+ //nin - number of inputs
+ //outid - event number of the output event
+
+ //create digits from summable digits
+ //conect tree with sSDigits
+
+
+ AliSimDigits ** digarr = new AliSimDigits*[nin];
+ for (Int_t i1=0;i1<nin; i1++){
+ digarr[i1]=0;
+ intree[i1].GetBranch("Segment")->SetAddress(&digarr[i1]);
+ }
+ Stat_t nentries = intree[0].GetEntries();
+
+ //make tree with digits
+ char dname[100];
+ sprintf(dname,"TreeD_%s_%d",fTPCParam->GetTitle(),outid);
+ AliTPCDigitsArray *arr = new AliTPCDigitsArray;
+ arr->SetClass("AliSimDigits");
+ arr->Setup(fTPCParam);
+ arr->MakeTree(fDigitsFile);
+
+ // set zero suppression
+
+ fTPCParam->SetZeroSup(2);
+
+ // get zero suppression
+
+ Int_t zerosup = fTPCParam->GetZeroSup();
+
+
+ AliTPCParam * par =fTPCParam;
+
+ //Loop over segments of the TPC
+ for (Int_t n=0; n<nentries; n++) {
+
+ for (Int_t i=0;i<nin; i++){
+ //connect proper digits
+ intree[i].GetEvent(n);
+ digarr[i]->ExpandBuffer();
+ digarr[i]->ExpandTrackBuffer();
+ }
+ Int_t sec, row;
+ if (!par->AdjustSectorRow(digarr[0]->GetID(),sec,row)) {
+ cerr<<"AliTPC warning: invalid segment ID ! "<<digarr[0]->GetID()<<endl;
+ continue;
+ }
+
+ AliSimDigits * digrow =(AliSimDigits*) arr->CreateRow(sec,row);
+ Int_t nrows = digrow->GetNRows();
+ Int_t ncols = digrow->GetNCols();
+
+ digrow->ExpandBuffer();
+ digrow->ExpandTrackBuffer();
+
+ for (Int_t rows=0;rows<nrows; rows++){
+ for (Int_t col=0;col<ncols; col++){
+ Float_t q=0;
+ Int_t label[1000]; // i hope no more than 300 events merged
+ Int_t labptr = 0;
+ // looop over digits
+ for (Int_t i=0;i<nin; i++){
+ q += digarr[i]->GetDigitFast(rows,col);
+ for (Int_t tr=0;tr<3;tr++) {
+ Int_t lab = digarr[i]->GetTrackIDFast(rows,col,tr);
+ if ( lab > 1) {
+ label[labptr]=lab+mask[i]-2;
+ labptr++;
+ }
+ }
+ }
+ //add noise
+ q = gRandom->Gaus(q,fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac()*16);
+
+ q/=16; //conversion faktor
+ q=(Short_t)q;
+
+ if (q> zerosup){
+
+ if(q > fTPCParam->GetADCSat()) q = fTPCParam->GetADCSat();
+ digrow->SetDigitFast((Short_t)q,rows,col);
+ for (Int_t tr=0;tr<3;tr++){
+ if (tr<labptr)
+ ((AliSimDigits*)digrow)->SetTrackIDFast(label[tr],rows,col,tr);
+ else
+ ((AliSimDigits*)digrow)->SetTrackIDFast(-1,rows,col,tr);
+ }
+ }
+ }
+ }
+ arr->StoreRow(sec,row);
+
+ arr->ClearRow(sec,row);
+
+ }
+
+ delete digarr;
+ arr->GetTree()->SetName(dname);
+ arr->GetTree()->Write();
+
+ delete arr;
+
+}
+
+/*_________________________________________
+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
+ GenerNoise(500000); //create teble with noise
//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);
+
+ fDigitsSwitch=0; // standard digits
+
+ cerr<<"Digitizing TPC -- normal digits...\n";
+
+ for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) if (IsSectorActive(isec)) Hits2DigitsSector(isec);
+ // write results
+
+ char treeName[100];
+
+ sprintf(treeName,"TreeD_%s_%d",fTPCParam->GetTitle(),eventnumber);
+
+ GetDigitsArray()->GetTree()->SetName(treeName);
+ GetDigitsArray()->GetTree()->Write();
+
+
+}
+
+
+
+//__________________________________________________________________
+void AliTPC::Hits2SDigits2(Int_t eventnumber)
+{
+
+ //-----------------------------------------------------------
+ // summable digits - 16 bit "ADC", no noise, no saturation
+ //-----------------------------------------------------------
+
+ //----------------------------------------------------
+ // Loop over all sectors for a single event
+ //----------------------------------------------------
+
+
+ if(fDefaults == 0) SetDefaults();
+ GenerNoise(500000); //create table with noise
+ //setup TPCDigitsArray
+
+ if(GetDigitsArray()) delete GetDigitsArray();
+
+ AliTPCDigitsArray *arr = new AliTPCDigitsArray;
+ arr->SetClass("AliSimDigits");
+ 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
+ cerr<<"Digitizing TPC -- summable digits...\n";
+
+ fDigitsSwitch=1; // summable digits
+
+ // set zero suppression to "0"
+
+ fTPCParam->SetZeroSup(0);
+
+ for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) if (IsSectorActive(isec)) Hits2DigitsSector(isec);
+
+
+ // write results
char treeName[100];
- sprintf(treeName,"TreeD_%s",param->GetTitle());
- GetDigitsArray()->GetTree()->Write(treeName,TObject::kOverwrite);
+
+ sprintf(treeName,"TreeS_%s_%d",fTPCParam->GetTitle(),eventnumber);
+
+ GetDigitsArray()->GetTree()->SetName(treeName);
+ GetDigitsArray()->GetTree()->Write();
+
}
-//__________________________________________________________________
-void AliTPC::Hits2Digits()
+
+
+//__________________________________________________________________
+void AliTPC::Hits2SDigits()
{
+
+ //-----------------------------------------------------------
+ // summable digits - 16 bit "ADC", no noise, no saturation
+ //-----------------------------------------------------------
+
//----------------------------------------------------
- // Loop over all sectors
+ // Loop over all sectors for a single event
//----------------------------------------------------
+ //MI change - for pp run
+ Int_t eventnumber = gAlice->GetEvNumber();
- if(fTPCParam == 0){
- printf("AliTPCParam MUST be created firstly\n");
- return;
- }
+ if(fDefaults == 0) SetDefaults();
+ GenerNoise(500000); //create table with noise
+
+ //setup TPCDigitsArray
+
+ if(GetDigitsArray()) delete GetDigitsArray();
+
+ AliTPCDigitsArray *arr = new AliTPCDigitsArray;
+ arr->SetClass("AliSimDigits");
+ arr->Setup(fTPCParam);
+ arr->MakeTree(fDigitsFile);
+ SetDigitsArray(arr);
+
+ cerr<<"Digitizing TPC -- summable digits...\n";
+
+ // fDigitsSwitch=1; // summable digits -for the moment direct
- for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
+ for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) if (IsSectorActive(isec)) Hits2DigitsSector(isec);
+
+
+ // write results
+ char treeName[100];
+
+ sprintf(treeName,"TreeD_%s_%d",fTPCParam->GetTitle(),eventnumber);
+
+ GetDigitsArray()->GetTree()->SetName(treeName);
+ GetDigitsArray()->GetTree()->Write();
}
// 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();
//--------------------------------------------------------
// Digitize this sector, row by row
- // row[i] is the pointer to the TObjArray of TVectors,
+ // row[i] is the pointer to the TObjArray of AliTPCFastVectors,
// each one containing electrons accepted on this
// row, assigned into tracks
//--------------------------------------------------------
for (i=0;i<nrows;i++){
- AliDigits * dig = fDigitsArray->CreateRow(isec,i);
+ AliDigits * dig = fDigitsArray->CreateRow(isec,i);
DigitizeRow(i,isec,row);
fDigitsArray->StoreRow(isec,i);
- Int_t ndig = dig->GetDigitSize();
-
-
- //printf("*** Sector, row, compressed digits %d %d %d ***\n",isec,i,ndig);
-
+ Int_t ndig = dig->GetDigitSize();
+ if (gDebug > 10) printf("*** Sector, row, compressed digits %d %d %d ***\n",isec,i,ndig);
+
fDigitsArray->ClearRow(isec,i);
// Integrated signal for this row
// and a single track signal
//
- TMatrix *m1 = new TMatrix(0,nofPads,0,nofTbins); // integrated
- TMatrix *m2 = new TMatrix(0,nofPads,0,nofTbins); // single
+
+ AliTPCFastMatrix *m1 = new AliTPCFastMatrix(0,nofPads,0,nofTbins); // integrated
+ AliTPCFastMatrix *m2 = new AliTPCFastMatrix(0,nofPads,0,nofTbins); // single
//
- TMatrix &total = *m1;
+ AliTPCFastMatrix &total = *m1;
// Array of pointers to the label-signal list
Int_t tracks[3];
AliDigits *dig = fDigitsArray->GetRow(isec,irow);
- for(Int_t ip=0;ip<nofPads;ip++){
- for(Int_t it=0;it<nofTbins;it++){
-
- Float_t q = total(ip,it);
-
- Int_t gi =it*nofPads+ip; // global index
+ Int_t gi=-1;
+ Float_t fzerosup = zerosup+0.5;
+ for(Int_t it=0;it<nofTbins;it++){
+ Float_t *pq = &(total.UncheckedAt(0,it));
+ for(Int_t ip=0;ip<nofPads;ip++){
+ gi++;
+ Float_t q=*pq;
+ pq++;
+ if(fDigitsSwitch == 0){
+ q+=GetNoise();
+ if(q <=fzerosup) continue; // do not fill zeros
+ q = TMath::Nint(q);
+ if(q > fTPCParam->GetADCSat()) q = fTPCParam->GetADCSat(); // saturation
- q = gRandom->Gaus(q,fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac());
-
- q = (Int_t)q;
+ }
- if(q <=zerosup) continue; // do not fill zeros
- if(q > fTPCParam->GetADCSat()) q = fTPCParam->GetADCSat(); // saturation
+ else {
+ if(q <= 0.) continue; // do not fill zeros
+ if(q>2000.) q=2000.;
+ q *= 16.;
+ q = TMath::Nint(q);
+ }
//
// "real" signal or electronic noise (list = -1)?
//
for(Int_t j1=0;j1<3;j1++){
- tracks[j1] = (pList[gi]) ?(Int_t)(*(pList[gi]+j1)) : -1;
+ tracks[j1] = (pList[gi]) ?(Int_t)(*(pList[gi]+j1)) : -2;
}
//Begin_Html
//_____________________________________________________________________________
-Float_t AliTPC::GetSignal(TObjArray *p1, Int_t ntr, TMatrix *m1, TMatrix *m2,
- Int_t *indexRange)
+Float_t AliTPC::GetSignal(TObjArray *p1, Int_t ntr,
+ AliTPCFastMatrix *m1, AliTPCFastMatrix *m2,Int_t *indexRange)
{
//---------------------------------------------------------------
// Modified: Marian Ivanov
//-----------------------------------------------------------------
- TVector *tv;
-
- tv = (TVector*)p1->At(ntr); // pointer to a track
- TVector &v = *tv;
+ AliTPCFastVector *tv;
+
+ tv = (AliTPCFastVector*)p1->At(ntr); // pointer to a track
+ AliTPCFastVector &v = *tv;
Float_t label = v(0);
Int_t centralPad = (fTPCParam->GetNPads(fCurrentIndex[1],fCurrentIndex[3])-1)/2;
indexRange[2]=9999; //min time
indexRange[3]=-1; // max time
- // Float_t IneffFactor = 0.5; // inefficiency in the gain close to the edge, as above
-
- TMatrix &signal = *m1;
- TMatrix &total = *m2;
+ AliTPCFastMatrix &signal = *m1;
+ AliTPCFastMatrix &total = *m2;
//
// Loop over all electrons
//
Float_t aval = v(idx+4);
Float_t eltoadcfac=aval*fTPCParam->GetTotalNormFac();
Float_t xyz[3]={v(idx+1),v(idx+2),v(idx+3)};
- Int_t n = fTPCParam->CalcResponse(xyz,fCurrentIndex,fCurrentIndex[3]);
-
- if (n>0) for (Int_t i =0; i<n; i++){
- Int_t *index = fTPCParam->GetResBin(i);
+ Int_t n = ((AliTPCParamSR*)fTPCParam)->CalcResponseFast(xyz,fCurrentIndex,fCurrentIndex[3]);
+
+ Int_t *index = fTPCParam->GetResBin(0);
+ Float_t *weight = & (fTPCParam->GetResWeight(0));
+
+ if (n>0) for (Int_t i =0; i<n; i++){
Int_t pad=index[1]+centralPad; //in digit coordinates central pad has coordinate 0
- if ( ( pad<(fTPCParam->GetNPads(fCurrentIndex[1],fCurrentIndex[3]))) && (pad>0)) {
+
+ if (pad>=0){
Int_t time=index[2];
- Float_t weight = fTPCParam->GetResWeight(i); //we normalise response to ADC channel
- weight *= eltoadcfac;
+ Float_t qweight = *(weight)*eltoadcfac;
- if (m1!=0) signal(pad,time)+=weight;
- total(pad,time)+=weight;
- indexRange[0]=TMath::Min(indexRange[0],pad);
- indexRange[1]=TMath::Max(indexRange[1],pad);
- indexRange[2]=TMath::Min(indexRange[2],time);
- indexRange[3]=TMath::Max(indexRange[3],time);
+ if (m1!=0) signal.UncheckedAt(pad,time)+=qweight;
+ total.UncheckedAt(pad,time)+=qweight;
+ if (indexRange[0]>pad) indexRange[0]=pad;
+ if (indexRange[1]<pad) indexRange[1]=pad;
+ if (indexRange[2]>time) indexRange[2]=time;
+ if (indexRange[3]<time) indexRange[3]=time;
+
+ index+=3;
+ weight++;
+
}
}
} // end of loop over electrons
}
//_____________________________________________________________________________
-void AliTPC::GetList(Float_t label,Int_t np,TMatrix *m,Int_t *indexRange,
- Float_t **pList)
+void AliTPC::GetList(Float_t label,Int_t np,AliTPCFastMatrix *m,
+ Int_t *indexRange, Float_t **pList)
{
//----------------------------------------------------------------------
// Updates the list of tracks contributing to digits for a given row
// Origin: Marek Kowalski IFJ, Krakow, Marek.Kowalski@ifj.edu.pl
//-----------------------------------------------------------------
- TMatrix &signal = *m;
+ AliTPCFastMatrix &signal = *m;
// lop over nonzero digits
AliTPChit *tpcHit; // pointer to a sigle TPC hit
//MI change
TBranch * branch=0;
- if (fHitType&2) branch = TH->GetBranch("TPC2");
+ if (fHitType>1) branch = TH->GetBranch("TPC2");
else branch = TH->GetBranch("TPC");
//----------------------------------------------
// Create TObjArray-s, one for each row,
- // each TObjArray will store the TVectors
- // of electrons, one TVector per each track.
+ // each TObjArray will store the AliTPCFastVectors
+ // of electrons, one AliTPCFastVectors per each track.
//----------------------------------------------
Int_t *nofElectrons = new Int_t [nrows]; // electron counter for each row
- TVector **tracks = new TVector* [nrows]; //pointers to the track vectors
+ AliTPCFastVector **tracks = new AliTPCFastVector* [nrows]; //pointers to the track vectors
+
for(i=0; i<nrows; i++){
row[i] = new TObjArray;
nofElectrons[i]=0;
for(Int_t track=0;track<ntracks;track++){
Bool_t isInSector=kTRUE;
ResetHits();
-
- if (fHitType&2) {
- isInSector=kFALSE;
- TBranch * br = TH->GetBranch("fTrackHitsInfo");
- br->GetEvent(track);
- AliObjectArray * ar = fTrackHits->fTrackHitsInfo;
- for (UInt_t j=0;j<ar->GetSize();j++){
- if ( ((AliTrackHitsInfo*)ar->At(j))->fVolumeID==isec) isInSector=kTRUE;
- }
- }
+ isInSector = TrackInVolume(isec,track);
if (!isInSector) continue;
//MI change
branch->GetEntry(track); // get next track
while(tpcHit){
Int_t sector=tpcHit->fSector; // sector number
- // if(sector != isec) continue;
if(sector != isec){
tpcHit = (AliTPChit*) NextHit();
continue;
for(i=0;i<nrows;i++){
if(previousTrack != -1){
if(nofElectrons[i]>0){
- TVector &v = *tracks[i];
+ AliTPCFastVector &v = *tracks[i];
v(0) = previousTrack;
tracks[i]->ResizeTo(4*nofElectrons[i]+1); // shrink if necessary
row[i]->Add(tracks[i]);
}
else{
- delete tracks[i]; // delete empty TVector
+ delete tracks[i]; // delete empty AliTPCFastVector
tracks[i]=0;
}
}
nofElectrons[i]=0;
- tracks[i] = new TVector(481); // TVectors for the next fTrack
+ tracks[i] = new AliTPCFastVector(481); // AliTPCFastVectors for the next fTrack
} // end of loop over rows
}
}
- TVector &v = *tracks[rowNumber];
+ AliTPCFastVector &v = *tracks[rowNumber];
Int_t idx = 4*nofElectrons[rowNumber]-3;
-
- v(idx)= xyz[0]; // X - pad row coordinate
- v(idx+1)=xyz[1]; // Y - pad coordinate (along the pad-row)
- v(idx+2)=xyz[2]; // Z - time bin coordinate
- v(idx+3)=xyz[3]; // avalanche size
+ Real_t * position = &(((AliTPCFastVector&)v).UncheckedAt(idx)); //make code faster
+ memcpy(position,xyz,4*sizeof(Float_t));
+
} // end of loop over electrons
tpcHit = (AliTPChit*)NextHit();
for(i=0;i<nrows;i++){
if(nofElectrons[i]>0){
- TVector &v = *tracks[i];
+ AliTPCFastVector &v = *tracks[i];
v(0) = previousTrack;
tracks[i]->ResizeTo(4*nofElectrons[i]+1); // shrink if necessary
row[i]->Add(tracks[i]);
branchname, &fDigits, buffersize, file);
}
- if (fHitType&2) MakeBranch2(option,file); // MI change 14.09.2000
+ if (fHitType>1) MakeBranch2(option,file); // MI change 14.09.2000
}
//_____________________________________________________________________________
//________________________________________________________________________
-// Additional code because of the AliTPCTrackHits
+// Additional code because of the AliTPCTrackHitsV2
void AliTPC::MakeBranch2(Option_t *option,const char *file)
{
// Create a new branch in the current Root Tree
// The branch of fHits is automatically split
// MI change 14.09.2000
- if (fHitType&2==0) return;
+ if (fHitType<2) return;
char branchname[10];
sprintf(branchname,"%s2",GetName());
//
// Get the pointer to the header
const char *cH = strstr(option,"H");
//
- if (fTrackHits && gAlice->TreeH() && cH) {
- AliObjectBranch * branch = new AliObjectBranch(branchname,"AliTPCTrackHits",&fTrackHits,
- gAlice->TreeH(),fBufferSize,1);
- gAlice->TreeH()->GetListOfBranches()->Add(branch);
+ if (fTrackHits && gAlice->TreeH() && cH && fHitType&4) {
+ // AliObjectBranch * branch = new AliObjectBranch(branchname,"AliTPCTrackHitsV2",&fTrackHits,
+ // gAlice->TreeH(),fBufferSize,99);
+ //TBranch * branch =
+ gAlice->TreeH()->Branch(branchname,"AliTPCTrackHitsV2",&fTrackHits,
+ fBufferSize,99);
+
+ // gAlice->TreeH()->GetListOfBranches()->Add(branch);
if (GetDebug()>1)
printf("* AliDetector::MakeBranch * Making Branch %s for trackhits\n",branchname);
const char folder [] = "RunMC/Event/Data";
cout << "Diverting branch " << branchname << " to file " << file << endl;
}
}
+
+ if (fTrackHitsOld && gAlice->TreeH() && cH && fHitType&2) {
+ AliObjectBranch * branch = new AliObjectBranch(branchname,"AliTPCTrackHits",&fTrackHitsOld,
+ gAlice->TreeH(),fBufferSize,99);
+ //TBranch * branch = gAlice->TreeH()->Branch(branchname,"AliTPCTrackHitsV2",&fTrackHits,
+ // fBufferSize,99);
+
+ gAlice->TreeH()->GetListOfBranches()->Add(branch);
+ if (GetDebug()>1)
+ printf("* AliDetector::MakeBranch * Making Branch %s for trackhits\n",branchname);
+ const char folder [] = "RunMC/Event/Data";
+ if (GetDebug())
+ printf("%15s: Publishing %s to %s\n",ClassName(),branchname,folder);
+ Publish(folder,&fTrackHitsOld,branchname);
+ if (file) {
+ TBranch *b = gAlice->TreeH()->GetBranch(branchname);
+ TDirectory *wd = gDirectory;
+ b->SetFile(file);
+ TIter next( b->GetListOfBranches());
+ while ((b=(TBranch*)next())) {
+ b->SetFile(file);
+ }
+ wd->cd();
+ if (GetDebug()>1)
+ cout << "Diverting branch " << branchname << " to file " << file << endl;
+ }
+ }
}
void AliTPC::SetTreeAddress()
{
- if (fHitType&1) AliDetector::SetTreeAddress();
- if (fHitType&2) SetTreeAddress2();
+ if (fHitType<=1) AliDetector::SetTreeAddress();
+ if (fHitType>1) SetTreeAddress2();
}
void AliTPC::SetTreeAddress2()
//
// Branch address for hit tree
TTree *treeH = gAlice->TreeH();
- if (treeH) {
+ if ((treeH)&&(fHitType&4)) {
branch = treeH->GetBranch(branchname);
if (branch) branch->SetAddress(&fTrackHits);
}
+ if ((treeH)&&(fHitType&2)) {
+ branch = treeH->GetBranch(branchname);
+ if (branch) branch->SetAddress(&fTrackHitsOld);
+ }
+
}
void AliTPC::FinishPrimary()
{
- if (fTrackHits) fTrackHits->FlushHitStack();
+ if (fTrackHits &&fHitType&4) fTrackHits->FlushHitStack();
+ if (fTrackHitsOld && fHitType&2) fTrackHitsOld->FlushHitStack();
}
//AliTPChit *hit = (AliTPChit*)fHits->UncheckedAt(fNhits-1);
//if (hit->fTrack!=rtrack)
// cout<<"bad track number\n";
- if (fTrackHits)
+ if (fTrackHits && fHitType&4)
fTrackHits->AddHitKartez(vol[0],rtrack, hits[0],
hits[1],hits[2],(Int_t)hits[3]);
+ if (fTrackHitsOld &&fHitType&2 )
+ fTrackHitsOld->AddHitKartez(vol[0],rtrack, hits[0],
+ hits[1],hits[2],(Int_t)hits[3]);
+
}
void AliTPC::ResetHits()
{
if (fHitType&1) AliDetector::ResetHits();
- if (fHitType&2) ResetHits2();
+ if (fHitType>1) ResetHits2();
}
void AliTPC::ResetHits2()
{
//
//reset hits
- if (fTrackHits) fTrackHits->Clear();
+ if (fTrackHits && fHitType&4) fTrackHits->Clear();
+ if (fTrackHitsOld && fHitType&2) fTrackHitsOld->Clear();
+
}
AliHit* AliTPC::FirstHit(Int_t track)
{
- if (fHitType&2) return FirstHit2(track);
+ if (fHitType>1) return FirstHit2(track);
return AliDetector::FirstHit(track);
}
AliHit* AliTPC::NextHit()
{
- if (fHitType&2) return NextHit2();
+ if (fHitType>1) return NextHit2();
+
return AliDetector::NextHit();
}
gAlice->TreeH()->GetEvent(track);
}
//
- if (fTrackHits) {
+ if (fTrackHits && fHitType&4) {
fTrackHits->First();
return fTrackHits->GetHit();
}
+ if (fTrackHitsOld && fHitType&2) {
+ fTrackHitsOld->First();
+ return fTrackHitsOld->GetHit();
+ }
+
else return 0;
}
//
//Return the next hit for the current track
+
+ if (fTrackHitsOld && fHitType&2) {
+ fTrackHitsOld->Next();
+ return fTrackHitsOld->GetHit();
+ }
if (fTrackHits) {
fTrackHits->Next();
return fTrackHits->GetHit();
void AliTPC::RemapTrackHitIDs(Int_t *map)
{
if (!fTrackHits) return;
- AliObjectArray * arr = fTrackHits->fTrackHitsInfo;
- for (UInt_t i=0;i<arr->GetSize();i++){
- AliTrackHitsInfo * info = (AliTrackHitsInfo *)(arr->At(i));
- info->fTrackID = map[info->fTrackID];
- }
+ if (fTrackHitsOld && fHitType&2){
+ AliObjectArray * arr = fTrackHitsOld->fTrackHitsInfo;
+ for (UInt_t i=0;i<arr->GetSize();i++){
+ AliTrackHitsInfo * info = (AliTrackHitsInfo *)(arr->At(i));
+ info->fTrackID = map[info->fTrackID];
+ }
+ }
+ if (fTrackHitsOld && fHitType&4){
+ TClonesArray * arr = fTrackHits->GetArray();;
+ for (Int_t i=0;i<arr->GetEntriesFast();i++){
+ AliTrackHitsParamV2 * info = (AliTrackHitsParamV2 *)(arr->At(i));
+ info->fTrackID = map[info->fTrackID];
+ }
+ }
}
+Bool_t AliTPC::TrackInVolume(Int_t id,Int_t track)
+{
+ //return bool information - is track in given volume
+ //load only part of the track information
+ //return true if current track is in volume
+ //
+ // return kTRUE;
+ if (fTrackHitsOld && fHitType&2) {
+ TBranch * br = gAlice->TreeH()->GetBranch("fTrackHitsInfo");
+ br->GetEvent(track);
+ AliObjectArray * ar = fTrackHitsOld->fTrackHitsInfo;
+ for (UInt_t j=0;j<ar->GetSize();j++){
+ if ( ((AliTrackHitsInfo*)ar->At(j))->fVolumeID==id) return kTRUE;
+ }
+ }
+
+ if (fTrackHits && fHitType&4) {
+ TBranch * br1 = gAlice->TreeH()->GetBranch("fVolumes");
+ TBranch * br2 = gAlice->TreeH()->GetBranch("fNVolumes");
+ br2->GetEvent(track);
+ br1->GetEvent(track);
+ Int_t *volumes = fTrackHits->GetVolumes();
+ Int_t nvolumes = fTrackHits->GetNVolumes();
+ if (!volumes && nvolumes>0) {
+ printf("Problematic track\t%d\t%d",track,nvolumes);
+ return kFALSE;
+ }
+ for (Int_t j=0;j<nvolumes; j++)
+ if (volumes[j]==id) return kTRUE;
+ }
+
+ if (fHitType&1) {
+ TBranch * br = gAlice->TreeH()->GetBranch("fSector");
+ br->GetEvent(track);
+ for (Int_t j=0;j<fHits->GetEntriesFast();j++){
+ if ( ((AliTPChit*)fHits->At(j))->fSector==id) return kTRUE;
+ }
+ }
+ return kFALSE;
+
+}
//_____________________________________________________________________________
void AliTPC::LoadPoints2(Int_t)
//
// Store x, y, z of all hits in memory
//
- if (fTrackHits == 0) return;
+ if (fTrackHits == 0 && fTrackHitsOld==0) return;
//
- Int_t nhits = fTrackHits->GetEntriesFast();
+ Int_t nhits =0;
+ if (fHitType&4) nhits = fTrackHits->GetEntriesFast();
+ if (fHitType&2) nhits = fTrackHitsOld->GetEntriesFast();
+
if (nhits == 0) return;
Int_t tracks = gAlice->GetNtrack();
if (fPoints == 0) fPoints = new TObjArray(tracks);
// Loop over all the hits and store their position
//
ahit = FirstHit2(-1);
- //for (Int_t hit=0;hit<nhits;hit++) {
while (ahit){
- // ahit = (AliHit*)fHits->UncheckedAt(hit);
trk=ahit->GetTrack();
if(ntrk[trk]==limi[trk]) {
//
ntrk[trk]++;
ahit = NextHit2();
}
+
+
+
//
for(trk=0; trk<tracks; ++trk) {
if(ntrk[trk]) {
Int_t ipart;
const Int_t kcmaxhits=30000;
- TVector * xxxx = new TVector(kcmaxhits*4);
- TVector & xxx = *xxxx;
+ AliTPCFastVector * xxxx = new AliTPCFastVector(kcmaxhits*4);
+ AliTPCFastVector & xxx = *xxxx;
Int_t maxhits = kcmaxhits;
//
} // end of loop over hits
xxxx->Delete();
-
+
+}
+//_______________________________________________________________________________
+void AliTPC::Digits2Reco(Int_t firstevent,Int_t lastevent)
+{
+ // produces rec points from digits and writes them on the root file
+ // AliTPCclusters.root
+
+ TDirectory *cwd = gDirectory;
+
+
+ AliTPCParam *dig=(AliTPCParam *)gDirectory->Get("75x40_100x60");
+ SetParam(dig);
+ cout<<"AliTPC::Digits2Reco: TPC parameteres have been set"<<endl;
+ TFile *out;
+ if(!gSystem->Getenv("CONFIG_FILE")){
+ out=TFile::Open("AliTPCclusters.root","recreate");
+ }
+ else {
+ const char *tmp1;
+ const char *tmp2;
+ char tmp3[80];
+ tmp1=gSystem->Getenv("CONFIG_FILE_PREFIX");
+ tmp2=gSystem->Getenv("CONFIG_OUTDIR");
+ sprintf(tmp3,"%s%s/AliTPCclusters.root",tmp1,tmp2);
+ out=TFile::Open(tmp3,"recreate");
+ }
+
+ TStopwatch timer;
+ cout<<"AliTPC::Digits2Reco - determination of rec points begins"<<endl;
+ timer.Start();
+ cwd->cd();
+ for(Int_t iev=firstevent;iev<lastevent+1;iev++){
+
+ printf("Processing event %d\n",iev);
+ Digits2Clusters(out,iev);
+ }
+ cout<<"AliTPC::Digits2Reco - determination of rec points ended"<<endl;
+ timer.Stop();
+ timer.Print();
+ out->Close();
+ cwd->cd();
}