* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-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
-
-Revision 1.34 2001/05/08 15:00:15 hristov
-Corrections for tracking in arbitrary magnenetic field. Changes towards a concept of global Alice track. Back propagation of reconstructed tracks (Yu.Belikov)
-
-Revision 1.33 2001/04/03 12:40:43 kowal2
-Removed printouts
-
-Revision 1.32 2001/03/12 17:47:36 hristov
-Changes needed on Sun with CC 5.0
-
-Revision 1.31 2001/03/12 08:21:50 kowal2
-Corrected C++ bug in the material definitions
-
-Revision 1.30 2001/03/01 17:34:47 kowal2
-Correction due to the accuracy problem
-
-Revision 1.29 2001/02/28 16:34:40 kowal2
-Protection against nonphysical values of the avalanche size,
-10**6 is the maximum
-
-Revision 1.28 2001/01/26 19:57:19 hristov
-Major upgrade of AliRoot code
-
-Revision 1.27 2001/01/13 17:29:33 kowal2
-Sun compiler correction
-
-Revision 1.26 2001/01/10 07:59:43 kowal2
-Corrections to load points from the noncompressed hits.
-
-Revision 1.25 2000/11/02 07:25:31 kowal2
-Changes due to the new hit structure.
-Memory leak removed.
-
-Revision 1.24 2000/10/05 16:06:09 kowal2
-Forward declarations. Changes due to a new class AliComplexCluster.
-
-Revision 1.23 2000/10/02 21:28:18 fca
-Removal of useless dependecies via forward declarations
-
-Revision 1.22 2000/07/10 20:57:39 hristov
-Update of TPC code and macros by M.Kowalski
-
-Revision 1.19.2.4 2000/06/26 07:39:42 kowal2
-Changes to obey the coding rules
-
-Revision 1.19.2.3 2000/06/25 08:38:41 kowal2
-Splitted from AliTPCtracking
-
-Revision 1.19.2.2 2000/06/16 12:59:28 kowal2
-Changed parameter settings
-
-Revision 1.19.2.1 2000/06/09 07:15:07 kowal2
-
-Defaults loaded automatically (hard-wired)
-Optional parameters can be set via macro called in the constructor
-
-Revision 1.19 2000/04/18 19:00:59 fca
-Small bug fixes to TPC files
-
-Revision 1.18 2000/04/17 09:37:33 kowal2
-removed obsolete AliTPCDigitsDisplay.C
-
-Revision 1.17.2.2 2000/04/10 08:15:12 kowal2
-
-New, experimental data structure from M. Ivanov
-New tracking algorithm
-Different pad geometry for different sectors
-Digitization rewritten
-
-Revision 1.17.2.1 2000/04/10 07:56:53 kowal2
-Not used anymore - removed
-
-Revision 1.17 2000/01/19 17:17:30 fca
-Introducing a list of lists of hits -- more hits allowed for detector now
-
-Revision 1.16 1999/11/05 09:29:23 fca
-Accept only signals > 0
-
-Revision 1.15 1999/10/08 06:26:53 fca
-Removed ClustersIndex - not used anymore
-
-Revision 1.14 1999/09/29 09:24:33 fca
-Introduction of the Copyright and cvs Log
-
-*/
+/* $Id$ */
///////////////////////////////////////////////////////////////////////////////
// //
//
+#include <Riostream.h>
+#include <stdlib.h>
+
+#include <TFile.h>
+#include <TGeometry.h>
+#include <TInterpreter.h>
#include <TMath.h>
-#include <TRandom.h>
-#include <TVector.h>
#include <TMatrix.h>
-#include <TGeometry.h>
#include <TNode.h>
-#include <TTUBS.h>
#include <TObjectTable.h>
-#include "TParticle.h"
-#include "AliTPC.h"
-#include <TFile.h>
-#include "AliRun.h"
-#include <iostream.h>
-#include <stdlib.h>
-#include <fstream.h>
-#include "AliMC.h"
-#include "AliMagF.h"
-
+#include <TParticle.h>
+#include <TROOT.h>
+#include <TRandom.h>
+#include <TSystem.h>
+#include <TTUBS.h>
+#include <TTree.h>
+#include <TVector.h>
+#include <TVirtualMC.h>
-#include "AliTPCParamSR.h"
-#include "AliTPCPRF2D.h"
-#include "AliTPCRF1D.h"
-#include "AliDigits.h"
-#include "AliSimDigits.h"
-#include "AliTPCTrackHits.h"
-#include "AliPoints.h"
#include "AliArrayBranch.h"
-
-
-#include "AliTPCDigitsArray.h"
-#include "AliComplexCluster.h"
#include "AliClusters.h"
-#include "AliTPCClustersRow.h"
+#include "AliComplexCluster.h"
+#include "AliDigits.h"
+#include "AliMagF.h"
+#include "AliPoints.h"
+#include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliSimDigits.h"
+#include "AliTPC.h"
+#include "AliTPC.h"
#include "AliTPCClustersArray.h"
-
+#include "AliTPCClustersRow.h"
+#include "AliTPCDigitsArray.h"
+#include "AliTPCLoader.h"
+#include "AliTPCPRF2D.h"
+#include "AliTPCParamSR.h"
+#include "AliTPCRF1D.h"
+#include "AliTPCTrackHits.h"
+#include "AliTPCTrackHitsV2.h"
#include "AliTPCcluster.h"
-#include "AliTPCclusterer.h"
-#include "AliTPCtracker.h"
+#include "AliTrackReference.h"
-#include <TInterpreter.h>
-#include <TTree.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);
+ virtual ~AliTPCFastVector(){;}
+ inline Float_t & UncheckedAt(Int_t index) const {return fElements[index];} //fast acces
+
+};
-ClassImp(AliTPC)
+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 = 2; //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);
+
+ fTrackHitsOld = new AliTPCTrackHits; //MI - 13.09.2000
+ fTrackHitsOld->SetHitPrecision(0.002);
+ fTrackHitsOld->SetStepPrecision(0.003);
+ fTrackHitsOld->SetMaxDistance(100);
+
+ fNoiseTable =0;
fHitType = 2;
+ 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::BuildGeometry()
{
return 9999;
}
-void AliTPC::Clusters2Tracks(TFile *of) {
+void AliTPC::Clusters2Tracks()
+ {
//-----------------------------------------------------------------
// This is a track finder.
//-----------------------------------------------------------------
- AliTPCtracker tracker(fTPCParam);
- tracker.Clusters2Tracks(gFile,of);
-}
+ Error("Clusters2Tracks",
+ "Dummy function ! Call AliTPCtracker::Clusters2Tracks(...) instead !");
+ }
//_____________________________________________________________________________
void AliTPC::CreateMaterials()
// gases - mixtures, ID >= 20 pure gases, <= 10 ID < 20 -compounds
//----------------------------------------------------------------
- char namate[21];
+ char namate[21]="";
density = 0.;
Float_t am=0;
Int_t nc;
}
+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());
+}
-void AliTPC::Digits2Clusters(TFile *of)
+
+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
+ SetTreeAddress();//just for security
+ 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(Int_t flag)
+{
+ //
+ // activate sectors which were hitted by tracks
+ //loop over tracks
+ SetTreeAddress();//just for security
+ if (fHitType==0) return; // if Clones hit - not short volume ID information
+ if (fActiveSectors) delete [] fActiveSectors;
+ fActiveSectors = new Bool_t[fTPCParam->GetNSector()];
+ if (flag) {
+ for (Int_t i=0;i<fTPCParam->GetNSector();i++) fActiveSectors[i]=kTRUE;
+ return;
+ }
+ for (Int_t i=0;i<fTPCParam->GetNSector();i++) fActiveSectors[i]=kFALSE;
+ TBranch * branch=0;
+ if (TreeH() == 0x0)
+ {
+ Fatal("SetActiveSectors","Can not find TreeH in folder");
+ return;
+ }
+ if (fHitType>1) branch = TreeH()->GetBranch("TPC2");
+ else branch = TreeH()->GetBranch("TPC");
+ Stat_t ntracks = TreeH()->GetEntries();
+ // loop over all hits
+ cout<<"\nAliTPC::SetActiveSectors(): Got "<<ntracks<<" tracks\n";
+
+ for(Int_t track=0;track<ntracks;track++)
+ {
+ ResetHits();
+ //
+ if (fTrackHits && fHitType&4) {
+ TBranch * br1 = TreeH()->GetBranch("fVolumes");
+ TBranch * br2 = 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 = 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(Int_t /*eventnumber*/)
{
//-----------------------------------------------------------------
// This is a simple cluster finder.
//-----------------------------------------------------------------
- AliTPCclusterer::Digits2Clusters(fTPCParam,of);
+ Error("Digits2Clusters",
+ "Dummy function ! Call AliTPCclusterer::Digits2Clusters(...) instead !");
}
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(Int_t /*eventn*/)
{
//--------------------------------------------------------
// TPC simple cluster generator from hits
const Float_t kBCz=0.55938e-3;
const Float_t kCCz=0.30428;
- TDirectory *savedir=gDirectory;
- if (!of->IsOpen()) {
+ if (!fLoader) {
cerr<<"AliTPC::Hits2Clusters(): output file not open !\n";
return;
}
- if(fTPCParam == 0){
- printf("AliTPCParam MUST be created firstly\n");
- return;
- }
+ //if(fDefaults == 0) SetDefaults();
Float_t sigmaRphi,sigmaZ,clRphi,clZ;
//
// Get the access to the tracks
//---------------------------------------------------------------
- TTree *tH = gAlice->TreeH();
+ TTree *tH = TreeH();
+ if (tH == 0x0)
+ {
+ Fatal("Hits2Clusters","Can not find TreeH in folder");
+ return;
+ }
+ SetTreeAddress();
+
Stat_t ntracks = tH->GetEntries();
//Switch to the output file
- of->cd();
+
+ if (fLoader->TreeR() == 0x0) fLoader->MakeTree("R");
+
+ cout<<"fTPCParam->GetTitle() = "<<fTPCParam->GetTitle()<<endl;
+
+ AliRunLoader* rl = (AliRunLoader*)fLoader->GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
+ rl->CdGAFile();
+ //fTPCParam->Write(fTPCParam->GetTitle());
- fTPCParam->Write(fTPCParam->GetTitle());
AliTPCClustersArray carray;
carray.Setup(fTPCParam);
carray.SetClusterType("AliTPCcluster");
- carray.MakeTree();
+ carray.MakeTree(fLoader->TreeR());
Int_t nclusters=0; //cluster counter
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()->Write();
-
- savedir->cd(); //switch back to the input file
+ fLoader->WriteRecPoints("OVERWRITE");
+
} // end of function
//
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++)
// Get the access to the tracks
//---------------------------------------------------------------
- TTree *tH = gAlice->TreeH();
+ TTree *tH = TreeH();
+ if (tH == 0x0)
+ {
+ Fatal("Hits2Clusters","Can not find TreeH in folder");
+ return;
+ }
+ SetTreeAddress();
+
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 detbz=currentIndex*(sumxz*sumx4-sumx2z*sumx3)-sumz*(sumx*sumx4-sumx2*sumx3)+
sumx2*(sumx*sumx2z-sumx2*sumxz);
+ if (TMath::Abs(det)<0.00001){
+ tpcHit = (AliTPChit*)NextHit();
+ continue;
+ }
+
Float_t y=detay/det+centralPad;
Float_t z=detaz/det;
Float_t by=detby/det; //y angle
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
+
+ //conect tree with sSDigits
+ TTree *t = fLoader->TreeS();
+
+ if (t == 0x0)
+ {
+ fLoader->LoadSDigits("READ");
+ t = fLoader->TreeS();
+ if (t == 0x0)
+ {
+ Error("SDigits2Digits2","Can not get input TreeS");
+ return;
+ }
+ }
+
+ if (fLoader->TreeD() == 0x0) fLoader->MakeTree("D");
+
+ AliSimDigits digarr, *dummy=&digarr;
+ TBranch* sdb = t->GetBranch("Segment");
+ if (sdb == 0x0)
+ {
+ Error("SDigits2Digits2","Can not find branch with segments in TreeS.");
+ return;
+ }
+
+ sdb->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(fLoader->TreeD());
+
+ 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))
+ {
+// cout<<n<<" NOT Active \n";
+ continue;
+ }
+ else
+ {
+// cout<<n<<" Active \n";
+ }
+ 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
+ fLoader->WriteDigits("OVERWRITE");
+
+ delete arr;
+}
+//__________________________________________________________________
+void AliTPC::SetDefaults(){
+
+
+ cerr<<"Setting default parameters...\n";
+
+ // Set response functions
+
+ //
+ AliRunLoader* rl = (AliRunLoader*)fLoader->GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
+ rl->CdGAFile();
AliTPCParamSR *param=(AliTPCParamSR*)gDirectory->Get("75x40_100x60");
+ if(param){
+ printf("You are using 2 pad-length geom hits with 3 pad-lenght geom digits...\n");
+ delete param;
+ param = new AliTPCParamSR();
+ }
+ else {
+ param=(AliTPCParamSR*)gDirectory->Get("75x40_100x60_150x60");
+ }
+ if(!param){
+ printf("No TPC parameters found\n");
+ exit(4);
+ }
+
+
AliTPCPRF2D * prfinner = new AliTPCPRF2D;
- AliTPCPRF2D * prfouter = new AliTPCPRF2D;
+ AliTPCPRF2D * prfouter1 = new AliTPCPRF2D;
+ AliTPCPRF2D * prfouter2 = 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");
+ prfouter1->Read("prf_10006_Gati_047051_d03");
+ prfouter2->Read("prf_15006_Gati_047051_d03");
f->Close();
- cwd->cd();
-
+ savedir->cd();
+
param->SetInnerPRF(prfinner);
- param->SetOuterPRF(prfouter);
+ param->SetOuter1PRF(prfouter1);
+ param->SetOuter2PRF(prfouter2);
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
+ //----------------------------------------------------
+ AliRunLoader* rl = (AliRunLoader*)fLoader->GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
+ rl->GetEvent(eventnumber);
+ if (fLoader->TreeH() == 0x0)
+ {
+ if(fLoader->LoadHits())
+ {
+ Error("Hits2Digits","Can not load hits.");
+ }
+ }
+ SetTreeAddress();
+
+ if (fLoader->TreeD() == 0x0 )
+ {
+ fLoader->MakeTree("D");
+ if (fLoader->TreeD() == 0x0 )
+ {
+ Error("Hits2Digits","Can not get TreeD");
+ return;
+ }
+ }
+
+ 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->MakeTree(fDigitsFile);
+ arr->Setup(fTPCParam);
+ arr->MakeTree(fLoader->TreeD());
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
+
+ cerr<<"Digitizing TPC -- normal digits...\n";
- char treeName[100];
- sprintf(treeName,"TreeD_%s",param->GetTitle());
- GetDigitsArray()->GetTree()->Write(treeName,TObject::kOverwrite);
+ for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++)
+ if (IsSectorActive(isec))
+ {
+ if (fDebug) Info("Hits2Digits","Sector %d is active.",isec);
+ Hits2DigitsSector(isec);
+ }
+ else
+ {
+ if (fDebug) Info("Hits2Digits","Sector %d is NOT active.",isec);
+ }
+
+ fLoader->WriteDigits("OVERWRITE");
+
+//this line prevents the crash in the similar one
+//on the beginning of this method
+//destructor attempts to reset the tree, which is deleted by the loader
+//need to be redesign
+ if(GetDigitsArray()) delete GetDigitsArray();
+ SetDigitsArray(0x0);
+
}
-//__________________________________________________________________
-void AliTPC::Hits2Digits()
+//__________________________________________________________________
+void AliTPC::Hits2SDigits2(Int_t eventnumber)
{
+
+ //-----------------------------------------------------------
+ // summable digits - 16 bit "ADC", no noise, no saturation
+ //-----------------------------------------------------------
+
//----------------------------------------------------
- // Loop over all sectors
+ // Loop over all sectors for a single event
//----------------------------------------------------
+// AliRunLoader* rl = (AliRunLoader*)fLoader->GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
- if(fTPCParam == 0){
- printf("AliTPCParam MUST be created firstly\n");
- return;
- }
+ AliRunLoader* rl = fLoader->GetRunLoader();
+
+ rl->GetEvent(eventnumber);
+ if (fLoader->TreeH() == 0x0)
+ {
+ if(fLoader->LoadHits())
+ {
+ Error("Hits2Digits","Can not load hits.");
+ return;
+ }
+ }
+ SetTreeAddress();
+
+
+ if (fLoader->TreeS() == 0x0 )
+ {
+ fLoader->MakeTree("S");
+ }
+
+ if(fDefaults == 0) SetDefaults();
- fDigitsSwitch=0;
+ GenerNoise(500000); //create table with noise
+ //setup TPCDigitsArray
- for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
+ if(GetDigitsArray()) delete GetDigitsArray();
-}
+
+ AliTPCDigitsArray *arr = new AliTPCDigitsArray;
+ arr->SetClass("AliSimDigits");
+ arr->Setup(fTPCParam);
+ arr->MakeTree(fLoader->TreeS());
+ SetDigitsArray(arr);
+
+ 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))
+ {
+// cout<<"Sector "<<isec<<" is active\n";
+ Hits2DigitsSector(isec);
+ }
+
+ fLoader->WriteSDigits("OVERWRITE");
+
+//this line prevents the crash in the similar one
+//on the beginning of this method
+//destructor attempts to reset the tree, which is deleted by the loader
+//need to be redesign
+ if(GetDigitsArray()) delete GetDigitsArray();
+ SetDigitsArray(0x0);
+}
//__________________________________________________________________
+
void AliTPC::Hits2SDigits()
{
//-----------------------------------------------------------
//----------------------------------------------------
- // Loop over all sectors
+ // Loop over all sectors for a single event
//----------------------------------------------------
+ //MI change - for pp run
+// Int_t eventnumber = gAlice->GetEvNumber();
+// AliRunLoader* rl = (AliRunLoader*)fLoader->GetEventFolder()->FindObject(AliRunLoader::fgkRunLoaderName);
+// rl->GetEvent(eventnumber);
+// 12/05/2003 This method is obsolete and not used. It should be redesingned
+// M.Kowalski
+
+ if (fLoader->TreeH() == 0x0)
+ {
+ if(fLoader->LoadHits())
+ {
+ Error("Hits2Digits","Can not load hits.");
+ }
+ }
+ SetTreeAddress();
- 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();
+
+ if (fLoader->TreeS() == 0x0 )
+ {
+ fLoader->MakeTree("S");
+ }
- fDigitsSwitch=1;
+ AliTPCDigitsArray *arr = new AliTPCDigitsArray;
+ arr->SetClass("AliSimDigits");
+ arr->Setup(fTPCParam);
+ arr->MakeTree(fLoader->TreeS());
+ SetDigitsArray(arr);
- for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
+ cerr<<"Digitizing TPC -- summable digits...\n";
-}
+ // fDigitsSwitch=1; // summable digits -for the moment direct
+ for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) if (IsSectorActive(isec)) Hits2DigitsSector(isec);
+
+ // write results
+ //
+ cout<<"Why method TPC::Hits2SDigits writes digits and not sdigits? skowron\n";
+ fLoader->WriteDigits("OVERWRITE");
+}
//_____________________________________________________________________________
+
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 = TreeH(); // pointer to the hits tree
+ if (tH == 0x0)
+ {
+ Fatal("Hits2DigitsSector","Can not find TreeH in folder");
+ return;
+ }
- TTree *tH = gAlice->TreeH(); // pointer to the hits tree
Stat_t ntracks = tH->GetEntries();
if( ntracks > 0){
Int_t nrows =fTPCParam->GetNRow(isec);
- row= new TObjArray* [nrows];
+ row= new TObjArray* [nrows+2]; // 2 extra rows for cross talk
MakeSector(isec,nrows,tH,ntracks,row);
//--------------------------------------------------------
// 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
//--------------------------------------------------------
Int_t i;
- if (fDigitsArray->GetTree()==0) fDigitsArray->MakeTree(fDigitsFile);
+ if (fDigitsArray->GetTree()==0)
+ {
+ Fatal("Hits2DigitsSector","Tree not set in fDigitsArray");
+ }
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);
} // end of the sector digitization
- for(i=0;i<nrows;i++){
+ for(i=0;i<nrows+2;i++){
row[i]->Delete();
delete row[i];
}
Float_t zerosup = fTPCParam->GetZeroSup();
- Int_t nrows =fTPCParam->GetNRow(isec);
+ // Int_t nrows =fTPCParam->GetNRow(isec);
fCurrentIndex[1]= isec;
// 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
//
//calculate signal
//
- Int_t row1 = TMath::Max(irow-fTPCParam->GetNCrossRows(),0);
- Int_t row2 = TMath::Min(irow+fTPCParam->GetNCrossRows(),nrows-1);
+ //Int_t row1 = TMath::Max(irow-fTPCParam->GetNCrossRows(),0);
+ //Int_t row2 = TMath::Min(irow+fTPCParam->GetNCrossRows(),nrows-1);
+ Int_t row1=irow;
+ Int_t row2=irow+2;
for (Int_t row= row1;row<=row2;row++){
Int_t nTracks= rows[row]->GetEntries();
for (i1=0;i1<nTracks;i1++){
fCurrentIndex[2]= row;
- fCurrentIndex[3]=irow;
- if (row==irow){
+ fCurrentIndex[3]=irow+1;
+ if (row==irow+1){
m2->Zero(); // clear single track signal matrix
Float_t trackLabel = GetSignal(rows[row],i1,m2,m1,indexRange);
GetList(trackLabel,nofPads,m2,indexRange,pList);
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 = gRandom->Gaus(q,fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac());
-
- q = (Int_t)q;
-
- if(q <=zerosup) continue; // do not fill zeros
+ q+=GetNoise();
+ if(q <=fzerosup) continue; // do not fill zeros
+ q = TMath::Nint(q);
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 = (Int_t)q;
+ q = TMath::Nint(q);
}
//
//
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;
+ Int_t centralPad = (fTPCParam->GetNPads(fCurrentIndex[1],fCurrentIndex[3]-1)-1)/2;
Int_t nElectrons = (tv->GetNrows()-1)/4;
indexRange[0]=9999; // min pad
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
- for(i=0; i<nrows; i++){
+ Int_t *nofElectrons = new Int_t [nrows+2]; // electron counter for each row
+ AliTPCFastVector **tracks = new AliTPCFastVector* [nrows+2]; //pointers to the track vectors
+
+ for(i=0; i<nrows+2; i++){
row[i] = new TObjArray;
nofElectrons[i]=0;
tracks[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;
// store already filled fTrack
- for(i=0;i<nrows;i++){
+ for(i=0;i<nrows+2;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
xyz[3]= (Float_t) (-gasgain*TMath::Log(rn));
index[0]=1;
- TransportElectron(xyz,index); //MI change -august
+ TransportElectron(xyz,index);
Int_t rowNumber;
- fTPCParam->GetPadRow(xyz,index); //MI change august
- rowNumber = index[2];
+ fTPCParam->GetPadRow(xyz,index);
+ // row 0 - cross talk from the innermost row
+ // row fNRow+1 cross talk from the outermost row
+ rowNumber = index[2]+1;
//transform position to local digit coordinates
//relative to nearest pad row
- if ((rowNumber<0)||rowNumber>=fTPCParam->GetNRow(isec)) continue;
+ if ((rowNumber<0)||rowNumber>fTPCParam->GetNRow(isec)+1) continue;
+ Float_t x1,y1;
+ if (isec <fTPCParam->GetNInnerSector()) {
+ x1 = xyz[1]*fTPCParam->GetInnerPadPitchWidth();
+ y1 = fTPCParam->GetYInner(rowNumber);
+ }
+ else{
+ x1=xyz[1]*fTPCParam->GetOuterPadPitchWidth();
+ y1 = fTPCParam->GetYOuter(rowNumber);
+ }
+ // gain inefficiency at the wires edges - linear
+ x1=TMath::Abs(x1);
+ y1-=1.;
+ if(x1>y1) xyz[3]*=TMath::Max(1.e-6,(y1-x1+1.));
+
nofElectrons[rowNumber]++;
//----------------------------------
// Expand vector if necessary
}
}
- 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();
// store remaining track (the last one) if not empty
//
- for(i=0;i<nrows;i++){
+ for(i=0;i<nrows+2;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]);
}
//_____________________________________________________________________________
-void AliTPC::MakeBranch(Option_t* option, const char *file)
+void AliTPC::MakeBranch(Option_t* option)
{
//
// Create Tree branches for the TPC.
//
+ if(GetDebug()) Info("MakeBranch","");
Int_t buffersize = 4000;
char branchname[10];
sprintf(branchname,"%s",GetName());
+
+ const char *h = strstr(option,"H");
- AliDetector::MakeBranch(option,file);
+ if ( h && (fHitType<=1) && (fHits == 0x0)) fHits = new TClonesArray("AliTPChit", 176);//skowron 20.06.03
+
+ AliDetector::MakeBranch(option);
const char *d = strstr(option,"D");
+
+ if (fDigits && fLoader->TreeD() && d)
+ {
+ MakeBranchInTree(gAlice->TreeD(), branchname, &fDigits, buffersize, 0);
+ }
- if (fDigits && gAlice->TreeD() && d) {
- MakeBranchInTree(gAlice->TreeD(),
- branchname, &fDigits, buffersize, file);
- }
-
- if (fHitType&2) MakeBranch2(option,file); // MI change 14.09.2000
+ if (fHitType>1) MakeBranch2(option,0); // MI change 14.09.2000
}
//_____________________________________________________________________________
//-----------------------------------------------------------------
// Origin: Marek Kowalski IFJ, Krakow, Marek.Kowalski@ifj.edu.pl
//-----------------------------------------------------------------
-
fSecAL = sec;
}
//-----------------------------------------------------------------
// Origin: Marek Kowalski IFJ, Krakow, Marek.Kowalski@ifj.edu.pl
//-----------------------------------------------------------------
-
fSecAU = sec;
}
// ExB
if (fTPCParam->GetMWPCReadout()==kTRUE){
- Float_t x1=xyz[0];
- fTPCParam->Transform2to2NearestWire(xyz,index);
- Float_t dx=xyz[0]-x1;
+ Float_t dx = fTPCParam->Transform2to2NearestWire(xyz,index);
xyz[1]+=dx*(fTPCParam->GetOmegaTau());
}
- //add nonisochronity (not implemented yet)
-
+ //add nonisochronity (not implemented yet)
}
ClassImp(AliTPCdigit)
fQ = hits[3];
}
-
//________________________________________________________________________
-// Additional code because of the AliTPCTrackHits
+// Additional code because of the AliTPCTrackHitsV2
-void AliTPC::MakeBranch2(Option_t *option,const char *file)
+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(GetDebug()) Info("MakeBranch2","");
+ 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 (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,&fTrackHits,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;
- }
- }
+ if (fTrackHits && TreeH() && cH && fHitType&4)
+ {
+ if(GetDebug()) Info("MakeBranch2","Making branch for Type 4 Hits");
+ TreeH()->Branch(branchname,"AliTPCTrackHitsV2",&fTrackHits,fBufferSize,99);
+ }
+
+ if (fTrackHitsOld && TreeH() && cH && fHitType&2)
+ {
+ if(GetDebug()) Info("MakeBranch2","Making branch for Type 2 Hits");
+ AliObjectBranch * branch = new AliObjectBranch(branchname,"AliTPCTrackHits",&fTrackHitsOld,
+ TreeH(),fBufferSize,99);
+ TreeH()->GetListOfBranches()->Add(branch);
+ }
}
void AliTPC::SetTreeAddress()
{
- if (fHitType&1) AliDetector::SetTreeAddress();
- if (fHitType&2) SetTreeAddress2();
+//Sets tree address for hits
+ if (fHitType<=1)
+ {
+ if (fHits == 0x0 ) fHits = new TClonesArray("AliTPChit", 176);//skowron 20.06.03
+ AliDetector::SetTreeAddress();
+ }
+ if (fHitType>1) SetTreeAddress2();
}
void AliTPC::SetTreeAddress2()
//
// Set branch address for the TrackHits Tree
//
+ if(GetDebug()) Info("SetTreeAddress2","");
+
TBranch *branch;
char branchname[20];
sprintf(branchname,"%s2",GetName());
//
// Branch address for hit tree
- TTree *treeH = gAlice->TreeH();
- if (treeH) {
+ TTree *treeH = TreeH();
+ if ((treeH)&&(fHitType&4)) {
branch = treeH->GetBranch(branchname);
- if (branch) branch->SetAddress(&fTrackHits);
+ if (branch)
+ {
+ branch->SetAddress(&fTrackHits);
+ if (GetDebug()) Info("SetTreeAddress2","fHitType&4 Setting");
+ }
+ else
+ if (GetDebug()) Info("SetTreeAddress2","fHitType&4 Failed (can not find branch)");
+
+ }
+ if ((treeH)&&(fHitType&2)) {
+ branch = treeH->GetBranch(branchname);
+ if (branch)
+ {
+ branch->SetAddress(&fTrackHitsOld);
+ if (GetDebug()) Info("SetTreeAddress2","fHitType&2 Setting");
+ }
+ else if (GetDebug())
+ Info("SetTreeAddress2","fHitType&2 Failed (can not find branch)");
+ }
+ //set address to TREETR
+
+ TTree *treeTR = TreeTR();
+ if (treeTR && fTrackReferences) {
+ branch = treeTR->GetBranch(GetName());
+ if (branch) branch->SetAddress(&fTrackReferences);
}
+
}
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]);
+ 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();
}
//
if(track>=0) {
gAlice->ResetHits();
- gAlice->TreeH()->GetEvent(track);
+ 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 = 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 = TreeH()->GetBranch("fVolumes");
+ TBranch * br2 = 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 = 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]) {
-void AliTPC::FindTrackHitsIntersection(TClonesArray * arr)
+void AliTPC::FindTrackHitsIntersection(TClonesArray * /*arr*/)
{
//
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;
+
+
+ AliTPCParamSR *dig=(AliTPCParamSR *)gDirectory->Get("75x40_100x60");
+ if(dig){
+ printf("You are running 2 pad-length geom hits with 3 pad-length geom digits\n");
+ delete dig;
+ dig = new AliTPCParamSR();
+ }
+ else
+ {
+ dig=(AliTPCParamSR *)gDirectory->Get("75x40_100x60_150x60");
+ }
+ if(!dig){
+ printf("No TPC parameters found\n");
+ exit(3);
+ }
+
+ 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(iev);
+ }
+ cout<<"AliTPC::Digits2Reco - determination of rec points ended"<<endl;
+ timer.Stop();
+ timer.Print();
+ out->Close();
+ cwd->cd();
+
+}
+
+AliLoader* AliTPC::MakeLoader(const char* topfoldername)
+{
+//Makes TPC loader
+ fLoader = new AliTPCLoader(GetName(),topfoldername);
+ return fLoader;
}
+
+////////////////////////////////////////////////////////////////////////
+AliTPCParam* AliTPC::LoadTPCParam(TFile *file) {
+//
+// load TPC paarmeters from a given file or create new if the object
+// is not found there
+// 12/05/2003 This method should be moved to the AliTPCLoader
+// and one has to decide where to store the TPC parameters
+// M.Kowalski
+ char paramName[50];
+ sprintf(paramName,"75x40_100x60_150x60");
+ AliTPCParam *paramTPC=(AliTPCParam*)file->Get(paramName);
+ if (paramTPC) {
+ cout<<"TPC parameters "<<paramName<<" found."<<endl;
+ } else {
+ cerr<<"TPC parameters not found. Create new (they may be incorrect)."
+ <<endl;
+ paramTPC = new AliTPCParamSR;
+ }
+ return paramTPC;
+
+// the older version of parameters can be accessed with this code.
+// In some cases, we have old parameters saved in the file but
+// digits were created with new parameters, it can be distinguish
+// by the name of TPC TreeD. The code here is just for the case
+// we would need to compare with old data, uncomment it if needed.
+//
+// char paramName[50];
+// sprintf(paramName,"75x40_100x60");
+// AliTPCParam *paramTPC=(AliTPCParam*)in->Get(paramName);
+// if (paramTPC) {
+// cout<<"TPC parameters "<<paramName<<" found."<<endl;
+// } else {
+// sprintf(paramName,"75x40_100x60_150x60");
+// paramTPC=(AliTPCParam*)in->Get(paramName);
+// if (paramTPC) {
+// cout<<"TPC parameters "<<paramName<<" found."<<endl;
+// } else {
+// cerr<<"TPC parameters not found. Create new (they may be incorrect)."
+// <<endl;
+// paramTPC = new AliTPCParamSR;
+// }
+// }
+// return paramTPC;
+
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff