Processing of many events possible now
authorkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 20 Jul 2001 14:32:44 +0000 (14:32 +0000)
committerkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 20 Jul 2001 14:32:44 +0000 (14:32 +0000)
13 files changed:
TPC/AliDigitsArray.cxx
TPC/AliTPC.cxx
TPC/AliTPC.h
TPC/AliTPCComparison.C
TPC/AliTPCDisplayClusters.C
TPC/AliTPCFindClusters.C
TPC/AliTPCFindTracks.C
TPC/AliTPCHits2Digits.C
TPC/AliTPCclusterer.cxx
TPC/AliTPCclusterer.h
TPC/AliTPCtracker.cxx
TPC/AliTPCtracker.h
TPC/TPCLinkDef.h

index bf91cc7..3021fb3 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.3  2000/10/05 16:03:07  kowal2
+Forward declarations. Destructor made virtual.
+
 Revision 1.2  2000/04/17 09:37:33  kowal2
 removed obsolete AliTPCDigitsDisplay.C
 
@@ -54,7 +57,7 @@ AliDigitsArray::AliDigitsArray()
 
 AliDigitsArray::~AliDigitsArray()
 {
-  if (fParam != 0) delete fParam;
+  // if (fParam != 0) delete fParam;
 }  
 
 Bool_t AliDigitsArray::Setup(AliDetectorParam *param)
index 8148aac..88b7c6c 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.37  2001/06/12 07:17:18  kowal2
+Hits2SDigits method implemented (summable digits)
+
 Revision 1.36  2001/05/16 14:57:25  alibrary
 New files for folders and Stack
 
@@ -134,7 +137,9 @@ Introduction of the Copyright and cvs Log
 #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>
@@ -183,7 +188,7 @@ AliTPC::AliTPC()
   //MI changes
   fDigitsArray = 0;
   fClustersArray = 0;
-  fTPCParam=0;
+  fDefaults = 0;
   fTrackHits = 0;  
   fHitType = 2;  
   fTPCParam = 0; 
@@ -204,6 +209,7 @@ AliTPC::AliTPC(const char *name, const char *title)
   //MI change  
   fDigitsArray = 0;
   fClustersArray= 0;
+  fDefaults = 0;
   //
   fTrackHits = new AliTPCTrackHits;  //MI - 13.09.2000
   fTrackHits->SetHitPrecision(0.002);
@@ -225,8 +231,9 @@ AliTPC::AliTPC(const char *name, const char *title)
   //  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;
@@ -776,18 +783,18 @@ void AliTPC::CreateMaterials()
 }
 
 
-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
@@ -826,10 +833,7 @@ void AliTPC::Hits2Clusters(TFile *of)
      return;
   }
 
-   if(fTPCParam == 0){
-     printf("AliTPCParam MUST be created firstly\n");
-     return;
-   }
+  //if(fDefaults == 0) SetDefaults();
 
   Float_t sigmaRphi,sigmaZ,clRphi,clZ;
   //
@@ -851,6 +855,10 @@ void AliTPC::Hits2Clusters(TFile *of)
   //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);
@@ -980,7 +988,7 @@ void AliTPC::Hits2Clusters(TFile *of)
 
   cerr<<"Number of made clusters : "<<nclusters<<"                        \n";
 
-  carray.GetTree()->Write();
+  carray.GetTree()->Write(cname);
 
   savedir->cd(); //switch back to the input file
   
@@ -1143,88 +1151,103 @@ void AliTPC::Hits2ExactClustersSector(Int_t isec)
  
 }
 //___________________________________________
-void AliTPC::SDigits2Digits()
+void AliTPC::SDigits2Digits(Int_t eventnumber)
 {
+
+
+  cerr<<"Digitizing TPC...\n";
+
+  Hits2Digits(eventnumber);
+   
+    
+  //write results
+
+  //  char treeName[100];
+
+  //  sprintf(treeName,"TreeD_%s_%d",fTPCParam->GetTitle(),eventnumber);
+  
+  //  GetDigitsArray()->GetTree()->Write(treeName);  
+}
+//__________________________________________________________________
+void AliTPC::SetDefaults(){
+
+   
+   cerr<<"Setting default parameters...\n";
+
+  // Set response functions
+
   AliTPCParamSR *param=(AliTPCParamSR*)gDirectory->Get("75x40_100x60");
   AliTPCPRF2D    * prfinner   = new AliTPCPRF2D;
   AliTPCPRF2D    * prfouter   = new AliTPCPRF2D;
   AliTPCRF1D     * rf    = new AliTPCRF1D(kTRUE);
-
-  TDirectory *cwd = gDirectory;
   rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
   rf->SetOffset(3*param->GetZSigma());
   rf->Update();
+  
+  TDirectory *savedir=gDirectory;
   TFile *f=TFile::Open("$ALICE_ROOT/TPC/AliTPCprf2d.root");
   if (!f->IsOpen()) { 
-     cerr<<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !\n";
+    cerr<<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !\n" ;
      exit(3);
   }
   prfinner->Read("prf_07504_Gati_056068_d02");
   prfouter->Read("prf_10006_Gati_047051_d03");
   f->Close();
-  cwd->cd();
-  
+  savedir->cd();
+
   param->SetInnerPRF(prfinner);
   param->SetOuterPRF(prfouter); 
   param->SetTimeRF(rf);
 
+  // set fTPCParam
+
   SetParam(param);
 
-  cerr<<"Digitizing TPC...\n";
+
+  fDefaults = 1;
+
+}
+//__________________________________________________________________  
+void AliTPC::Hits2Digits(Int_t eventnumber)  
+{ 
+ //----------------------------------------------------
+ // Loop over all sectors for a single event
+ //----------------------------------------------------
+
+
+  if(fDefaults == 0) SetDefaults();  // check if the parameters are set
 
   //setup TPCDigitsArray 
+
+  if(GetDigitsArray()) delete GetDigitsArray();
+
   AliTPCDigitsArray *arr = new AliTPCDigitsArray; 
   arr->SetClass("AliSimDigits");
-  arr->Setup(param);
-  SetParam(param);
+  arr->Setup(fTPCParam);
   arr->MakeTree(fDigitsFile);
-
   SetDigitsArray(arr);
 
-  Hits2Digits();
-   
-  // Hits2DigitsSector(1);         
-  // Hits2DigitsSector(2);             
-  // Hits2DigitsSector(3);             
-  // Hits2DigitsSector(1+18);             
-  // Hits2DigitsSector(2+18);             
-  // Hits2DigitsSector(3+18);             
-
-  // Hits2DigitsSector(36+1);             
-  // Hits2DigitsSector(36+2);             
-  // Hits2DigitsSector(36+3);             
-  // Hits2DigitsSector(36+1+18);             
-  // Hits2DigitsSector(36+2+18);             
-  // Hits2DigitsSector(36+3+18); 
-     
-  //write results
+  fDigitsSwitch=0; // standard digits
 
-  char treeName[100];
-  sprintf(treeName,"TreeD_%s",param->GetTitle());
-  GetDigitsArray()->GetTree()->Write(treeName,TObject::kOverwrite);
-}
+  cerr<<"Digitizing TPC...\n";
 
-//__________________________________________________________________  
-void AliTPC::Hits2Digits()  
-{ 
- //----------------------------------------------------
- // Loop over all sectors
- //----------------------------------------------------
+ for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
 
-  if(fTPCParam == 0){
-    printf("AliTPCParam MUST be created firstly\n");
-    return;
-  } 
+  // write results
+
+  char treeName[100];
+
+  sprintf(treeName,"TreeD_%s_%d",fTPCParam->GetTitle(),eventnumber);
   
-  fDigitsSwitch=0;
+  GetDigitsArray()->GetTree()->Write(treeName);  
 
- for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
 
 }
 
+
+
 //__________________________________________________________________
-void AliTPC::Hits2SDigits()  
+void AliTPC::Hits2SDigits(Int_t eventnumber)  
 { 
 
   //-----------------------------------------------------------
@@ -1232,20 +1255,41 @@ void AliTPC::Hits2SDigits()
   //-----------------------------------------------------------
 
  //----------------------------------------------------
- // Loop over all sectors
+ // Loop over all sectors for a single event
  //----------------------------------------------------
 
-  if(fTPCParam == 0){
-    printf("AliTPCParam MUST be created firstly\n");
-    return;
-  } 
-  
-  fDigitsSwitch=1;
+
+  if(fDefaults == 0) SetDefaults();
+
+  //setup TPCDigitsArray 
+
+  if(GetDigitsArray()) delete GetDigitsArray();
+
+  AliTPCDigitsArray *arr = new AliTPCDigitsArray; 
+  arr->SetClass("AliSimDigits");
+  arr->Setup(fTPCParam);
+  arr->MakeTree(fDigitsFile);
+  SetDigitsArray(arr);
+
+  cerr<<"Digitizing TPC...\n"; 
+
+  fDigitsSwitch=1; // summable digits
 
  for(Int_t isec=0;isec<fTPCParam->GetNSector();isec++) Hits2DigitsSector(isec);
 
+
+  // write results
+
+  char treeName[100];
+
+  sprintf(treeName,"TreeS_%s_%d",fTPCParam->GetTitle(),eventnumber);
+  
+  GetDigitsArray()->GetTree()->Write(treeName); 
+
 }
 
+
+
 //_____________________________________________________________________________
 void AliTPC::Hits2DigitsSector(Int_t isec)
 {
@@ -1261,6 +1305,10 @@ void AliTPC::Hits2DigitsSector(Int_t isec)
   //  Get the access to the track hits
   //-------------------------------------------------------
 
+  // check if the parameters are set - important if one calls this method
+  // directly, not from the Hits2Digits
+
+  if(fDefaults == 0) SetDefaults();
 
   TTree *tH = gAlice->TreeH(); // pointer to the hits tree
   Stat_t ntracks = tH->GetEntries();
@@ -1273,7 +1321,7 @@ void AliTPC::Hits2DigitsSector(Int_t isec)
 
     TObjArray **row;
     
-    //printf("*** Processing sector number %d ***\n",isec);
+    printf("*** Processing sector number %d ***\n",isec);
 
       Int_t nrows =fTPCParam->GetNRow(isec);
 
@@ -1294,7 +1342,7 @@ void AliTPC::Hits2DigitsSector(Int_t isec)
 
       for (i=0;i<nrows;i++){
 
-               AliDigits * dig = fDigitsArray->CreateRow(isec,i); 
+       AliDigits * dig = fDigitsArray->CreateRow(isec,i); 
 
        DigitizeRow(i,isec,row);
 
@@ -1303,7 +1351,7 @@ void AliTPC::Hits2DigitsSector(Int_t isec)
                Int_t ndig = dig->GetDigitSize(); 
         
  
-       //printf("*** Sector, row, compressed digits %d %d %d ***\n",isec,i,ndig);
+     printf("*** Sector, row, compressed digits %d %d %d ***\n",isec,i,ndig);
        
         fDigitsArray->ClearRow(isec,i);  
 
@@ -2497,7 +2545,10 @@ void AliTPC::FindTrackHitsIntersection(TClonesArray * arr)
                
   } // end of loop over hits
   xxxx->Delete();
-
 
 }
+//_______________________________________________________________________________
+void AliTPC::Digits2Reco(Int_t eventnumber)
+{
+  // empty for a time being
+}
index 6ee3bd7..13a6e35 100644 (file)
@@ -24,6 +24,7 @@ class AliTPCTrackHits; // M.I.
 
 class AliTPC : public AliDetector {
 protected:
+  Int_t          fDefaults;
   Int_t          fSens;             // ISENS
   Int_t          fSecAL;            // Upper sector selector
   Int_t          fSecAU;            // Lower sector selector
@@ -55,15 +56,16 @@ public:
   virtual void  BuildGeometry();
   virtual void  CreateGeometry() {}
   virtual void  CreateMaterials();
-  virtual void  Hits2Clusters(TFile *of);
+  virtual void  Hits2Clusters(TFile *of, Int_t eventn);
   virtual void  Hits2ExactClustersSector(Int_t isec); // MI change calculate "exact" cluster position
-  virtual void  SDigits2Digits();
-  virtual void  Hits2SDigits();
-  virtual void  Hits2Digits();   //MI change
+  virtual void  SDigits2Digits(Int_t eventnumber=0);
+  virtual void  Hits2SDigits(Int_t eventnumber=0);
+  virtual void  Digits2Reco(Int_t eventnumber=0);
+  virtual void  Hits2Digits(Int_t eventnumber=0);   //MI change
   virtual void  Hits2DigitsSector(Int_t isec);  //MI change
   virtual void  Init();
   virtual Int_t IsVersion() const =0;
-  virtual void  Digits2Clusters(TFile *of);
+  virtual void  Digits2Clusters(TFile *of, Int_t eventnumber=0);
   virtual void  Clusters2Tracks(TFile *of);
 
   Int_t         GetNsectors()       {return fNsectors;}
@@ -112,10 +114,12 @@ public:
    //middle of the row
    void SetHitType(Int_t type){fHitType =type;} //set type of hit container
    void SetDigitsSwitch(Int_t sw){fDigitsSwitch = sw;}
+   void SetDefSwitch(Int_t def){fDefaults = def;}
 
 
 private:
   //
+  void SetDefaults();
   void DigitizeRow(Int_t irow,Int_t isec,TObjArray **rowTriplet);
   Float_t GetSignal(TObjArray *p1, Int_t ntr, TMatrix *m1, TMatrix *m2,
                     Int_t *IndexRange);
@@ -128,7 +132,7 @@ private:
                          // index[2] pad row number  
                          // index[3] pad row number for which signal is calculated
   
-  ClassDef(AliTPC,3)  // Time Projection Chamber class
+  ClassDef(AliTPC,4)  // Time Projection Chamber class
 };
 
 
index 48159fa..7c4c1f3 100644 (file)
@@ -4,14 +4,15 @@
 #endif
 
 struct GoodTrack {
+  Int_t fEventN; //event number
   Int_t lab;
   Int_t code;
   Float_t px,py,pz;
   Float_t x,y,z;
 };
-Int_t good_tracks(GoodTrack *gt, Int_t max);
+Int_t good_tracks(GoodTrack *gt, Int_t max, Int_t eventn=1);
 
-Int_t AliTPCComparison() {
+Int_t AliTPCComparison(Int_t eventn=1) {
    cerr<<"Doing comparison...\n";
    Int_t i;
    gBenchmark->Start("AliTPCComparison");
@@ -20,47 +21,70 @@ Int_t AliTPCComparison() {
    if (!cf->IsOpen()) {cerr<<"Can't open AliTPCclusters.root !\n"; return 1;}
    AliTPCParam *digp= (AliTPCParam*)cf->Get("75x40_100x60");
    if (!digp) { cerr<<"TPC parameters have not been found !\n"; return 2; }
-   AliTPCtracker *tracker = new AliTPCtracker(digp);
 
-// Load clusters
-   tracker->LoadInnerSectors();
-   tracker->LoadOuterSectors();
 
-// Load tracks
-   TFile *tf=TFile::Open("AliTPCtracks.root");
-   if (!tf->IsOpen()) {cerr<<"Can't open AliTPCtracks.root !\n"; return 3;}
+
+   ///////////
+   AliTPCtracker *tracker =0; 
    TObjArray tarray(2000);
-   TTree *tracktree=(TTree*)tf->Get("TPCf");
-   if (!tracktree) {cerr<<"Can't get a tree with TPC tracks !\n"; return 4;}
-   TBranch *tbranch=tracktree->GetBranch("tracks");
-   Int_t nentr=(Int_t)tracktree->GetEntries();
-   
    AliTPCtrack *iotrack=0;
-   for (i=0; i<nentr; i++) {
+   Int_t nentr= 0;
+   Int_t eventptr[1000];
+   TFile *tf=TFile::Open("AliTPCtracks.root");
+   TTree *tracktree=0;
+   // Load clusters
+   eventptr[0]=0;
+   eventptr[1]=0;
+   for (Int_t event=0;event<eventn; event++){
+     cf->cd();
+     tracker = new AliTPCtracker(digp,event);
+     tracker->LoadInnerSectors();
+     tracker->LoadOuterSectors();
+     char   tname[100];
+     if (eventn==-1) {
+       sprintf(tname,"TreeT_TPC");
+     }
+     else {
+       sprintf(tname,"TreeT_TPC_%d",event);
+     }
+
+     // Load tracks
+     if (!tf->IsOpen()) {cerr<<"Can't open AliTPCtracks.root !\n"; return 3;}
+     tracktree=(TTree*)tf->Get(tname);
+     if (!tracktree) {cerr<<"Can't get a tree with TPC tracks !\n"; return 4;}
+     TBranch *tbranch=tracktree->GetBranch("tracks");
+     Int_t nentr0=(Int_t)tracktree->GetEntries();
+     nentr+=nentr0;
+     for (i=0; i<nentr0; i++) {
        iotrack=new AliTPCtrack;
        tbranch->SetAddress(&iotrack);
        tracktree->GetEvent(i);
        tracker->CookLabel(iotrack,0.1);
        tarray.AddLast(iotrack);
-   }   
-
-   delete tracker;
-
+     }   
+     eventptr[event+1] = nentr;  //store end of the event
+     delete tracker;
+   }
    tf->Close();
    cf->Close();
+  
+   //MI change for a moment
+
 
 /////////////////////////////////////////////////////////////////////////
-   GoodTrack gt[15000];
+   //   GoodTrack gt[15000];
+   GoodTrack gt[45000];
+
    Int_t ngood=0;
    ifstream in("good_tracks_tpc");
    if (in) {
       cerr<<"Reading good tracks...\n";
-      while (in>>gt[ngood].lab>>gt[ngood].code>>
+      while (in>>gt[ngood].fEventN>>gt[ngood].lab>>gt[ngood].code>>
                  gt[ngood].px>>gt[ngood].py>>gt[ngood].pz>>
                  gt[ngood].x >>gt[ngood].y >>gt[ngood].z) {
          ngood++;
          cerr<<ngood<<'\r';
-         if (ngood==15000) {
+         if (ngood==45000) {
             cerr<<"Too many good tracks !\n";
             break;
          }
@@ -68,16 +92,17 @@ Int_t AliTPCComparison() {
       if (!in.eof()) cerr<<"Read error (good_tracks_tpc) !\n";
    } else {
       cerr<<"Marking good tracks (this will take a while)...\n";
-      ngood=good_tracks(gt,15000);
+      ngood=good_tracks(gt,45000,eventn);   //mi change
       ofstream out("good_tracks_tpc");
       if (out) {
          for (Int_t ngd=0; ngd<ngood; ngd++)            
-           out<<gt[ngd].lab<<' '<<gt[ngd].code<<' '<<
+          out<<gt[ngd].fEventN<<' '<<gt[ngd].lab<<' '<<gt[ngd].code<<' '<<
                  gt[ngd].px<<' '<<gt[ngd].py<<' '<<gt[ngd].pz<<' '<<
                  gt[ngd].x <<' '<<gt[ngd].y <<' '<<gt[ngd].z <<endl;
       } else cerr<<"Can not open file (good_tracks_tpc) !\n";
       out.close();
 
+      /*
       cerr<<"Preparing tracks for matching with the ITS...\n";
       tarray.Sort();
       tf=TFile::Open("AliTPCtracks.root","recreate");
@@ -89,6 +114,7 @@ Int_t AliTPCComparison() {
       }
       tracktree->Write();
       tf->Close();
+      */
    }
    cerr<<"Number of good tracks : "<<ngood<<endl;
 
@@ -133,14 +159,19 @@ Int_t AliTPCComparison() {
       if (ptg<pmin) continue;
 
       hgood->Fill(ptg);
+      Int_t ievent = gt[ngood].fEventN;
 
       AliTPCtrack *track=0;
-      for (i=0; i<nentr; i++) {
+      //      for (i=0; i<nentr; i++) {
+      for (i=eventptr[ievent]; i<eventptr[ievent+1]; i++) {
+
           track=(AliTPCtrack*)tarray.UncheckedAt(i);
           tlab=track->GetLabel();
           if (lab==TMath::Abs(tlab)) break;
       }
-      if (i==nentr) {
+      //      if (i==nentr) {
+      if (i==eventptr[ievent+1]) {
+
        //cerr<<"Track "<<lab<<" was not found !\n";
        track_notfound[itrack_notfound++]=lab;
         continue;
@@ -150,7 +181,9 @@ Int_t AliTPCComparison() {
       Int_t micount=0;
       Int_t mi;
       AliTPCtrack * mitrack;
-      for (mi=0; mi<nentr; mi++) {
+      //      for (mi=0; mi<nentr; mi++) {
+      for (mi=eventptr[ievent]; mi<eventptr[ievent+1]; mi++) {
+
        mitrack=(AliTPCtrack*)tarray.UncheckedAt(mi);          
        if (lab==TMath::Abs(mitrack->GetLabel())) micount++;
       }
@@ -302,8 +335,8 @@ Int_t AliTPCComparison() {
 }
 
 
-Int_t good_tracks(GoodTrack *gt, Int_t max) {
-   Int_t nt=0;
+Int_t good_tracks(GoodTrack *gt, Int_t max, Int_t eventn) {
+  //eventn  - number of events in file
 
    TFile *file=TFile::Open("rfio:galice.root");
    if (!file->IsOpen()) {cerr<<"Can't open galice.root !\n"; exit(4);}
@@ -313,7 +346,7 @@ Int_t good_tracks(GoodTrack *gt, Int_t max) {
      exit(5);
    }
 
-   Int_t np=gAlice->GetEvent(0);   
+   //   Int_t np=gAlice->GetEvent(0); //MI change   
 
    AliTPC *TPC=(AliTPC*)gAlice->GetDetector("TPC");
    Int_t ver = TPC->IsVersion(); 
@@ -329,134 +362,145 @@ Int_t good_tracks(GoodTrack *gt, Int_t max) {
    Int_t gap=Int_t(0.125*nrows);
    Int_t good_number=Int_t(0.4*nrows);
 
-   Int_t *good=new Int_t[np];
-   for (Int_t ii=0; ii<np; ii++) good[ii]=0;
-
-
-   //MI change to be possible compile macro
-   //definition out of the swith statemnet
-    Int_t sectors_by_rows=0;
-    TTree *TD=0;
-    AliSimDigits da, *digits=&da;
-    Int_t *count=0;
-   switch (ver) {
-   case 1:
-     {
-      TFile *cf=TFile::Open("AliTPCclusters.root");
-      if (!cf->IsOpen()){cerr<<"Can't open AliTPCclusters.root !\n";exit(5);}
-      AliTPCClustersArray *ca=new AliTPCClustersArray;
-      ca->Setup(digp);
-      ca->SetClusterType("AliTPCcluster");
-      ca->ConnectTree("Segment Tree");
-      Int_t nrows=Int_t(ca->GetTree()->GetEntries());
-      for (Int_t n=0; n<nrows; n++) {
-          AliSegmentID *s=ca->LoadEntry(n);
-          Int_t sec,row;
-          digp->AdjustSectorRow(s->GetID(),sec,row);
-          AliTPCClustersRow &clrow = *ca->GetRow(sec,row);
-          Int_t ncl=clrow.GetArray()->GetEntriesFast();
-          while (ncl--) {
-              AliTPCcluster *c=(AliTPCcluster*)clrow[ncl];
-              Int_t lab=c->GetLabel(0);
-              if (lab<0) continue; //noise cluster
-              lab=TMath::Abs(lab);
-              if (sec>=digp->GetNInnerSector())
-              if (row==nrow_up-1    ) good[lab]|=0x1000;
-              if (sec>=digp->GetNInnerSector())
-              if (row==nrow_up-1-gap) good[lab]|=0x800;
-              good[lab]++;
-          }
-          ca->ClearRow(sec,row);
-      }
-      cf->Close();
-     }
-      break;
-   case 2:
-      TD=(TTree*)gDirectory->Get("TreeD_75x40_100x60");
-      TD->GetBranch("Segment")->SetAddress(&digits);
-      count = new Int_t[np];
-      Int_t i;
-      for (i=0; i<np; i++) count[i]=0;
-      sectors_by_rows=(Int_t)TD->GetEntries();
-      for (i=0; i<sectors_by_rows; i++) {
-          if (!TD->GetEvent(i)) continue;
-          Int_t sec,row;
-          digp->AdjustSectorRow(digits->GetID(),sec,row);
-          cerr<<sec<<' '<<row<<"                                     \r";
-          digits->First();
-          do { //Many thanks to J.Chudoba who noticed this
-              Int_t it=digits->CurrentRow(), ip=digits->CurrentColumn();
-              Short_t dig = digits->GetDigit(it,ip);
-              Int_t idx0=digits->GetTrackID(it,ip,0); 
-              Int_t idx1=digits->GetTrackID(it,ip,1);
-              Int_t idx2=digits->GetTrackID(it,ip,2);
-              if (idx0>=0 && dig>=zero) count[idx0]+=1;
-              if (idx1>=0 && dig>=zero) count[idx1]+=1;
-              if (idx2>=0 && dig>=zero) count[idx2]+=1;
-          } while (digits->Next());
-          for (Int_t j=0; j<np; j++) {
-              if (count[j]>1) {
-                 if (sec>=digp->GetNInnerSector())
-                  if (row==nrow_up-1    ) good[j]|=0x1000;
-                 if (sec>=digp->GetNInnerSector())
-                  if (row==nrow_up-1-gap) good[j]|=0x800;
-                 good[j]++;
-              }
-              count[j]=0;
-          }
-      }
-      delete[] count;
-      break;
-   default:
-      cerr<<"Invalid TPC version !\n";
-      file->Close();
-      exit(7);
-   }
-
-   TTree *TH=gAlice->TreeH();
-   Int_t npart=(Int_t)TH->GetEntries();
 
-   while (npart--) {
-      AliTPChit *hit0=0;
-
-      TPC->ResetHits();
-      TH->GetEvent(npart);
-      AliTPChit * hit = (AliTPChit*) TPC->FirstHit(-1);
-      while (hit){
-       if (hit->fQ==0.) break;
+   //MI change
+   Int_t nt=0;  //reset counter
+   char treeName[100];  //declare event identifier
+       
+   for (Int_t event=0;event<eventn;event++){
+
+     Int_t np=gAlice->GetEvent(event);   
+     Int_t *good=new Int_t[np];
+     for (Int_t ii=0; ii<np; ii++) good[ii]=0;
+     
+     
+     //MI change to be possible compile macro
+     //definition out of the swith statemnet
+     Int_t sectors_by_rows=0;
+     TTree *TD=0;
+     AliSimDigits da, *digits=&da;
+     Int_t *count=0;
+     switch (ver) {
+     case 1:
+       {
+        TFile *cf=TFile::Open("AliTPCclusters.root");
+        if (!cf->IsOpen()){cerr<<"Can't open AliTPCclusters.root !\n";exit(5);}
+        AliTPCClustersArray *ca=new AliTPCClustersArray;
+        ca->Setup(digp);
+        ca->SetClusterType("AliTPCcluster");
+        ca->ConnectTree("Segment Tree");
+        Int_t nrows=Int_t(ca->GetTree()->GetEntries());
+        for (Int_t n=0; n<nrows; n++) {
+          AliSegmentID *s=ca->LoadEntry(n);
+          Int_t sec,row;
+          digp->AdjustSectorRow(s->GetID(),sec,row);
+          AliTPCClustersRow &clrow = *ca->GetRow(sec,row);
+          Int_t ncl=clrow.GetArray()->GetEntriesFast();
+          while (ncl--) {
+            AliTPCcluster *c=(AliTPCcluster*)clrow[ncl];
+            Int_t lab=c->GetLabel(0);
+            if (lab<0) continue; //noise cluster
+            lab=TMath::Abs(lab);
+            if (sec>=digp->GetNInnerSector())
+              if (row==nrow_up-1    ) good[lab]|=0x1000;
+            if (sec>=digp->GetNInnerSector())
+              if (row==nrow_up-1-gap) good[lab]|=0x800;
+            good[lab]++;
+          }
+          ca->ClearRow(sec,row);
+        }
+        cf->Close();
+       }
+     break;
+     case 2:
+
+       sprintf(treeName,"TreeD_75x40_100x60_%d",event);       
+       TD=(TTree*)gDirectory->Get(treeName);
+       TD->GetBranch("Segment")->SetAddress(&digits);
+       count = new Int_t[np];
+       Int_t i;
+       for (i=0; i<np; i++) count[i]=0;
+       sectors_by_rows=(Int_t)TD->GetEntries();
+       for (i=0; i<sectors_by_rows; i++) {
+        if (!TD->GetEvent(i)) continue;
+        Int_t sec,row;
+        digp->AdjustSectorRow(digits->GetID(),sec,row);
+        cerr<<sec<<' '<<row<<"                                     \r";
+        digits->First();
+        do { //Many thanks to J.Chudoba who noticed this
+          Int_t it=digits->CurrentRow(), ip=digits->CurrentColumn();
+          Short_t dig = digits->GetDigit(it,ip);
+          Int_t idx0=digits->GetTrackID(it,ip,0); 
+          Int_t idx1=digits->GetTrackID(it,ip,1);
+          Int_t idx2=digits->GetTrackID(it,ip,2);
+          if (idx0>=0 && dig>=zero) count[idx0]+=1;
+          if (idx1>=0 && dig>=zero) count[idx1]+=1;
+          if (idx2>=0 && dig>=zero) count[idx2]+=1;
+          } while (digits->Next());
+        for (Int_t j=0; j<np; j++) {
+          if (count[j]>1) {
+            if (sec>=digp->GetNInnerSector())
+              if (row==nrow_up-1    ) good[j]|=0x1000;
+            if (sec>=digp->GetNInnerSector())
+              if (row==nrow_up-1-gap) good[j]|=0x800;
+            good[j]++;
+          }
+          count[j]=0;
+        }
+       }
+       delete[] count;
+       break;
+     default:
+       cerr<<"Invalid TPC version !\n";
+       file->Close();
+       exit(7);
+     }
+     
+     TTree *TH=gAlice->TreeH();
+     Int_t npart=(Int_t)TH->GetEntries();
+
+     while (npart--) {
+       AliTPChit *hit0=0;
+       
+       TPC->ResetHits();
+       TH->GetEvent(npart);
+       AliTPChit * hit = (AliTPChit*) TPC->FirstHit(-1);
+       while (hit){
+        if (hit->fQ==0.) break;
        hit =  (AliTPChit*) TPC->NextHit();
-      }
-      if (hit) {
-       hit0 = new AliTPChit(*hit); //Make copy of hit
-       hit = hit0;
-      }
-      else continue;
-      AliTPChit *hit1=(AliTPChit*)TPC->NextHit();      
-      if (hit1==0) continue;
-      if (hit1->fQ != 0.) continue;
-      Int_t i=hit->Track();
-      TParticle *p = (TParticle*)gAlice->Particle(i);
-
-      if (p->GetFirstMother()>=0) continue;  //secondary particle
-      if (good[i] < 0x1000+0x800+2+good_number) continue;
-      if (p->Pt()<0.100) continue;
-      if (TMath::Abs(p->Pz()/p->Pt())>0.999) continue;
-
-      gt[nt].lab=i;
-      gt[nt].code=p->GetPdgCode();
-//**** px py pz - in global coordinate system, x y z - in local !
-      gt[nt].px=hit->X(); gt[nt].py=hit->Y(); gt[nt].pz=hit->Z();
-      Float_t cs,sn; digp->AdjustCosSin(hit1->fSector,cs,sn);
-      gt[nt].x = hit1->X()*cs + hit1->Y()*sn;
-      gt[nt].y =-hit1->X()*sn + hit1->Y()*cs;
-      gt[nt].z = hit1->Z();
-      nt++;    
-       if (hit0) delete hit0;
-      cerr<<i<<"                \r";
-      if (nt==max) {cerr<<"Too many good tracks !\n"; break;}
+       }
+       if (hit) {
+        hit0 = new AliTPChit(*hit); //Make copy of hit
+        hit = hit0;
+       }
+       else continue;
+       AliTPChit *hit1=(AliTPChit*)TPC->NextHit();     
+       if (hit1==0) continue;
+       if (hit1->fQ != 0.) continue;
+       Int_t i=hit->Track();
+       TParticle *p = (TParticle*)gAlice->Particle(i);
+       
+       if (p->GetFirstMother()>=0) continue;  //secondary particle
+       if (good[i] < 0x1000+0x800+2+good_number) continue;
+       if (p->Pt()<0.100) continue;
+       if (TMath::Abs(p->Pz()/p->Pt())>0.999) continue;
+       
+       gt[nt].lab=i;
+       gt[nt].code=p->GetPdgCode();
+       //**** px py pz - in global coordinate system, x y z - in local !
+       gt[nt].px=hit->X(); gt[nt].py=hit->Y(); gt[nt].pz=hit->Z();
+       Float_t cs,sn; digp->AdjustCosSin(hit1->fSector,cs,sn);
+       gt[nt].fEventN=event;  //MI change
+       gt[nt].x = hit1->X()*cs + hit1->Y()*sn;
+       gt[nt].y =-hit1->X()*sn + hit1->Y()*cs;
+       gt[nt].z = hit1->Z();
+       nt++;   
+       if (hit0) delete hit0;
+       cerr<<i<<"                \r";
+       if (nt==max) {cerr<<"Too many good tracks !\n"; break;}
+     }
+     delete[] good;
    }
-   delete[] good;
-
    delete gAlice; gAlice=0;
 
    file->Close();
index 3e66817..89588af 100644 (file)
@@ -1,7 +1,7 @@
-Int_t AliTPCDisplayClusters() {
+Int_t AliTPCDisplayClusters(Int_t eventn) {
    cerr<<"Displaying clusters...\n";
 
-   TFile *file=TFile::Open("rfio:galice.root");
+   TFile *file=TFile::Open("galice.root");
    if (!file->IsOpen()) {cerr<<"Can't open galice.root !\n"; return 1;}
 
    TFile *cf=TFile::Open("AliTPCclusters.root");
@@ -21,7 +21,10 @@ Int_t AliTPCDisplayClusters() {
    AliTPCClustersArray *ca=new AliTPCClustersArray;
    ca->Setup(dig);
    ca->SetClusterType("AliTPCcluster");
-   ca->ConnectTree("Segment Tree");
+   char  cname[100];
+   sprintf(cname,"TreeC_TPC_%d",eventn);
+
+   ca->ConnectTree(cname);
    Int_t nrows=Int_t(ca->GetTree()->GetEntries());
    for (Int_t n=0; n<nrows; n++) {
        AliSegmentID *s=ca->LoadEntry(n);
index 6d3dbff..4e72316 100644 (file)
@@ -9,7 +9,7 @@
   #include "TStopwatch.h"
 #endif
 
-Int_t AliTPCFindClusters() {
+Int_t AliTPCFindClusters(Int_t n) {
    TFile *out=TFile::Open("AliTPCclusters.root","new");
    if (!out->IsOpen()) {cerr<<"Delete old AliTPCclusters.root !\n"; return 1;}
    TFile *in=TFile::Open("rfio:galice.root");
@@ -22,8 +22,6 @@ Int_t AliTPCFindClusters() {
 
    TDirectory *cwd = gDirectory;
 
-   gAlice->GetEvent(0);
-
    AliTPC *TPC = (AliTPC*)gAlice->GetDetector("TPC"); 
    Int_t ver = TPC->IsVersion(); 
    cerr<<"TPC version "<<ver<<" has been found !\n";
@@ -38,15 +36,25 @@ Int_t AliTPCFindClusters() {
       cerr<<"Making clusters...\n";
       {
        AliTPCv1 &tpc=*((AliTPCv1*)TPC);
-       tpc.SetParam(dig); timer.Start(); cwd->cd(); tpc.Hits2Clusters(out); 
+       tpc.SetParam(dig); timer.Start(); cwd->cd(); 
+       for(Int_t i=0;i<n;i++){
+         printf("Processing event %d\n",i);
+         gAlice->GetEvent(i);
+         tpc.Hits2Clusters(out,i);
+       } 
       }
       break;
    case 2:
       cerr<<"Looking for clusters...\n";
       {
-       delete gAlice; gAlice=0;
+       // delete gAlice; gAlice=0;
        AliTPCv2 tpc; 
-       tpc.SetParam(dig); timer.Start(); cwd->cd(); tpc.Digits2Clusters(out); 
+       tpc.SetParam(dig); timer.Start(); cwd->cd();  
+       for (Int_t i=0;i<n;i++){
+        printf("Processing event %d\n",i);
+         tpc.Digits2Clusters(out,i);
+        //      AliTPCclusterer::Digits2Clusters(dig, out, i);
+       }
       }
       break;
    default:
index 75e91b9..1fcd31c 100644 (file)
@@ -6,7 +6,7 @@
   #include "TStopwatch.h"
 #endif
 
-Int_t AliTPCFindTracks() {
+Int_t AliTPCFindTracks(Int_t eventn=1) { 
    cerr<<"Looking for tracks...\n";
 
    TFile *out=TFile::Open("AliTPCtracks.root","new");
@@ -19,13 +19,17 @@ Int_t AliTPCFindTracks() {
    if (!par) {cerr<<"Can't get TPC parameters !\n"; return 3;}
  
    TStopwatch timer;
-   AliTPCtracker *tracker = new AliTPCtracker(par);
-   Int_t rc=tracker->Clusters2Tracks(0,out);
+
+   for (Int_t i=0;i<eventn;i++){
+     printf("Processing event %d\n",i);
+     AliTPCtracker *tracker = new AliTPCtracker(par,i);
+     Int_t rc=tracker->Clusters2Tracks(0,out);
+   }
    delete tracker;
    timer.Stop(); timer.Print();
  
    in->Close();
    out->Close();
 
-   return rc;
+   return 1;
 }
index f849b47..11680a9 100644 (file)
@@ -1,4 +1,4 @@
-Int_t AliTPCHits2Digits()
+Int_t AliTPCHits2Digits(Int_t nevent=1)
 {
 
   // new version by J.Belikov
@@ -23,68 +23,26 @@ Int_t AliTPCHits2Digits()
     return 2;
   }
 
-  gAlice->GetEvent(0);
-  AliTPC *TPC = (AliTPC*)gAlice->GetDetector("TPC");      
-
-//Set response functions
-
-  AliTPCParamSR *param=(AliTPCParamSR*)gDirectory->Get("75x40_100x60");
-  AliTPCPRF2D    * prfinner   = new AliTPCPRF2D;
-  AliTPCPRF2D    * prfouter   = new AliTPCPRF2D;
-  AliTPCRF1D     * rf    = new AliTPCRF1D(kTRUE);
-  rf->SetGauss(param->GetZSigma(),param->GetZWidth(),1.);
-  rf->SetOffset(3*param->GetZSigma());
-  rf->Update();
-
-  TDirectory *savedir=gDirectory;
-  TFile *f=TFile::Open("$ALICE_ROOT/TPC/AliTPCprf2d.root");
-  if (!f->IsOpen()) { 
-     cerr<<"Can't open $ALICE_ROOT/TPC/AliTPCprf2d.root !\n"
-     return 3;
-  }
-  prfinner->Read("prf_07504_Gati_056068_d02");
-  prfouter->Read("prf_10006_Gati_047051_d03");
-  f->Close();
-  savedir->cd();
 
-  param->SetInnerPRF(prfinner);
-  param->SetOuterPRF(prfouter); 
-  param->SetTimeRF(rf);
-  TPC->SetParam(param);
-   
-  cerr<<"Digitizing TPC...\n";
 
-  //setup TPCDigitsArray 
-  AliTPCDigitsArray *arr = new AliTPCDigitsArray; 
-  arr->SetClass("AliSimDigits");
-  arr->Setup(param);
-  TPC->SetParam(param);
-  arr->MakeTree();
+  // gAlice->GetEvent(0);
+  AliTPC *TPC = (AliTPC*)gAlice->GetDetector("TPC");      
 
-  TPC->SetDigitsArray(arr);
-  TPC->Hits2Digits();
-  /*  TPC->Hits2DigitsSector(1);             
-  TPC->Hits2DigitsSector(2);             
-  TPC->Hits2DigitsSector(3);             
-  TPC->Hits2DigitsSector(1+18);             
-  TPC->Hits2DigitsSector(2+18);             
-  TPC->Hits2DigitsSector(3+18);             
+  TStopwatch timer;
+  timer.Start();
 
-  TPC->Hits2DigitsSector(36+1);             
-  TPC->Hits2DigitsSector(36+2);             
-  TPC->Hits2DigitsSector(36+3);             
-  TPC->Hits2DigitsSector(36+1+18);             
-  TPC->Hits2DigitsSector(36+2+18);             
-  TPC->Hits2DigitsSector(36+3+18); */
-            
-  //write results
+  for(Int_t eventn =0;eventn<nevent;eventn++){
+    printf("Processing event %d",eventn);
+    gAlice->GetEvent(eventn);
 
-  char treeName[100];
-  sprintf(treeName,"TreeD_%s",param->GetTitle());
-  TPC->GetDigitsArray()->GetTree()->Write(treeName);
+    TPC->Hits2Digits(eventn);
+  }
 
   delete gAlice; gAlice=0;
   file->Close(); delete file;
+  timer.Stop();
+  timer.Print();
+
   return 0;
 };
 
index 3980b9f..2edbd63 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.4  2001/04/17 08:06:27  hristov
+Possibility to define the magnetic field in the reconstruction (Yu.Belikov)
+
 Revision 1.3  2000/10/05 16:14:01  kowal2
 Forward declarations.
 
@@ -96,7 +99,7 @@ AliTPCcluster &c) {
 }
 
 //_____________________________________________________________________________
-void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of)
+void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of, Int_t eventn)
 {
   //-----------------------------------------------------------------
   // This is a simple cluster finder.
@@ -110,7 +113,21 @@ void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of)
 
   const Int_t kMAXZ=par->GetMaxTBin()+2;
 
-  TTree *t = (TTree *)gDirectory->Get("TreeD_75x40_100x60");
+  char  dname[100];
+  char   cname[100];
+  if (eventn==-1) {
+
+    // for backward compatibility
+    
+    sprintf(dname,"TreeD_75x40_100x60");
+    sprintf(cname,"TreeC_TPC");
+  }
+  else {
+    sprintf(dname,"TreeD_75x40_100x60_%d",eventn);
+    sprintf(cname,"TreeC_TPC_%d",eventn);
+  }
+  TTree *t = (TTree *)gDirectory->Get(dname);
+
   AliSimDigits digarr, *dummy=&digarr;
   t->GetBranch("Segment")->SetAddress(&dummy);
   Stat_t nentries = t->GetEntries();
@@ -123,6 +140,8 @@ void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of)
   carray.SetClusterType("AliTPCcluster");
   carray.MakeTree();
 
+
+
   Int_t nclusters=0;
 
   for (Int_t n=0; n<nentries; n++) {
@@ -255,7 +274,7 @@ void AliTPCclusterer::Digits2Clusters(const AliTPCParam *par, TFile *of)
 
   cerr<<"Number of found clusters : "<<nclusters<<"                        \n";
 
-  carray.GetTree()->Write();
+  carray.GetTree()->Write(cname);
   savedir->cd();
 }
 
index a85475b..48bedac 100644 (file)
@@ -20,7 +20,7 @@ class AliTPCcluster;
 
 class AliTPCclusterer {
 public:
-   static void Digits2Clusters(const AliTPCParam *par, TFile *of);
+   static void Digits2Clusters(const AliTPCParam *par, TFile *of, Int_t eventn=1);
 
 private:
    class AliBin {
index fd39eb1..bb9ebc6 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.11  2001/05/23 08:50:10  hristov
+Weird inline removed
+
 Revision 1.10  2001/05/16 14:57:25  alibrary
 New files for folders and Stack
 
@@ -55,8 +58,15 @@ Splitted from AliTPCtracking
 #include "AliTPCParam.h"
 #include "AliTPCClustersRow.h"
 
+
+AliTPCtracker::AliTPCtracker(const AliTPCParam *par)
+{;
+//MI change only provisore - need change in the ITS code which depend on it
+}
+
+
 //_____________________________________________________________________________
-AliTPCtracker::AliTPCtracker(const AliTPCParam *par): 
+AliTPCtracker::AliTPCtracker(const AliTPCParam *par, Int_t eventn): 
 fkNIS(par->GetNInnerSector()/2), 
 fkNOS(par->GetNOuterSector()/2)
 {
@@ -74,8 +84,18 @@ fkNOS(par->GetNOuterSector()/2)
 
   fClustersArray.Setup(par);
   fClustersArray.SetClusterType("AliTPCcluster");
-  fClustersArray.ConnectTree("Segment Tree");
 
+  char   cname[100];
+  if (eventn==-1) {
+    sprintf(cname,"TreeC_TPC");
+  }
+  else {
+    sprintf(cname,"TreeC_TPC_%d",eventn);
+  }
+
+  fClustersArray.ConnectTree(cname);
+
+  fEventN = eventn;
   fSeeds=0;
 }
 
@@ -655,7 +675,16 @@ Int_t AliTPCtracker::Clusters2Tracks(const TFile *inp, TFile *out) {
   }  
   UnloadInnerSectors();
 
-  tracktree.Write();
+  char   tname[100];
+  if (fEventN==-1) {
+    sprintf(tname,"TreeT_TPC");
+  }
+  else {
+    sprintf(tname,"TreeT_TPC_%d",fEventN);
+  }
+
+
+  tracktree.Write(tname);
 
   cerr<<"Number of found tracks : "<<found<<endl;
 
index e27d1d2..410d9e1 100644 (file)
@@ -22,7 +22,8 @@ class AliTPCParam;
 class AliTPCtracker : public AliTracker {
 public:
    AliTPCtracker():AliTracker(),fkNIS(0),fkNOS(0) {}
-   AliTPCtracker(const AliTPCParam *par);
+   AliTPCtracker(const AliTPCParam *par, Int_t eventn);
+  AliTPCtracker(const AliTPCParam *par);
   ~AliTPCtracker();
 
    Int_t ReadSeeds(const TFile *in);
@@ -93,8 +94,7 @@ public:
      Double_t fAlpha;                    //opening angle
      Double_t fAlphaShift;               //shift angle;
      Double_t fPadPitchWidth;            //pad pitch width
-     Double_t fPadPitchLength;           //pad pitch length
-
+     Double_t fPadPitchLength;           //pad pitch length    
    private:
      AliTPCSector(const AliTPCSector &s);           //dummy copy contructor
      AliTPCSector& operator=(const AliTPCSector &s);//dummy assignment operator
@@ -136,6 +136,7 @@ private:
    Int_t fN;               //number of loaded sectors
    AliTPCSector *fSectors; //pointer to loaded sectors;
 
+  Int_t fEventN;                      //event number
    AliTPCClustersArray fClustersArray; //array of TPC clusters
    TObjArray *fSeeds;                  //array of track seeds 
 };
index d91c9ef..d2efdb4 100644 (file)
@@ -53,5 +53,9 @@
 #pragma link C++ class AliHitInfo+;
 
 
+#pragma link C++ class AliTPCclusterer-;
+
+
+
 #endif