HLT/src/AliLevel3_Root.cxx

   1 //Author:        Uli Frankenfeld
   2 //Author:        Anders Strand Vestbo
   3 //Last Modified: 13.12.2000
   4
   5 #include <TFile.h>
   6 #include <TDirectory.h>
   7 #include <TClonesArray.h>
   8 #include <TStopwatch.h>
   9 #include <iostream.h>
  10
  11 #include "AliL3Logging.h"
  12 #include "AliLevel3_Root.h"
  13 #include "AliL3ConfMapper.h"
  14 #include "AliL3Vertex.h"
  15 #include "AliL3VertexFinder.h"
  16 #include "AliL3TrackMerger.h"
  17 #include "AliL3GlobalMerger.h"
  18 #include "AliL3InterMerger.h"
  19 #include "AliL3ConfMapPoint.h"
  20 #include "AliL3ConfMapTrack.h"
  21 #include "AliL3Transform.h"
  22 #include "AliL3ClustFinder.h"
  23 #include "AliL3DigitData.h"
  24 #include "AliL3TrackArray.h"
  25 #include "AliL3MemHandler.h"
  26 #include "AliL3Benchmark.h"
  27
  28 #include "AliL3DigitData.h"
  29 #include "AliL3TrackSegmentData.h"
  30 #include "AliL3SpacePointData.h"
  31 #include "AliL3VertexData.h"
  32
  33 //_______________________________________
  34 //
  35 //  AliLevel3
  36 //
  37 //  Interface class for Level3 tracker.
  38 //  Tracking is done by calling constructor with input,output
  39 //  given as argument.
  40 //  You must always remember to set the tracking parameters. E.g.:
  41 //
  42 //  AliLevel3 *level3 = new AliLevel3(inputfile,outputfile);
  43 //  level3->SetTrackerParam(); //Sets default tracking parameters
  44 //  level3->ProcessSector(2,2);  //Does tracking on sector 2 (actually 2+38)
  45
  46 ClassImp(AliLevel3)
  47
  48 AliLevel3::AliLevel3(){
  49   fInputFile=0;
  50   fOutputFile=0;
  51   Init();
  52 }
  53
  54 AliLevel3::AliLevel3(Char_t *infile,Char_t *outfile){
  55   //Constructor. Calls constructor of the tracker, vertexfinder and merger classes.
  56
  57   fOutputFile = new TFile(outfile,"NEW");
  58
  59   if(!fOutputFile->IsOpen())
  60     {
  61     LOG(AliL3Log::kWarning, "AliLevel3::AliLevel3","File Open")
  62     <<"Delete your old "<<outfile<<" file!"<<ENDLOG;
  63     }
  64   fInputFile = new TFile(infile,"READ");
  65
  66   if(!fInputFile->IsOpen())
  67     {
  68     LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
  69     <<"Inputfile "<<infile<<" does not exist"<<ENDLOG;
  70     return;
  71     }
  72
  73   Init();
  74 }
  75
  76 AliLevel3::AliLevel3(TFile *in, TFile *out){
  77   fOutputFile = out;
  78   fInputFile  =  in;
  79   if(!in){
  80     LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
  81     <<"Pointer to InFile 0x0!"<<ENDLOG;
  82     return;
  83   }
  84   if(!out){
  85     LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
  86     <<"Pointer to OutFile 0x0!"<<ENDLOG;
  87     return;
  88   }
  89
  90   if(!fOutputFile->IsOpen())
  91     {
  92     LOG(AliL3Log::kWarning,"AliLevel3::AliLevel3","File Open")
  93     <<"no output file!"<<ENDLOG;
  94       return;
  95     }
  96   if(!fInputFile->IsOpen())
  97     {
  98     LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
  99     <<"Inputfile does not exist"<<ENDLOG;
 100       return;
 101     }
 102   Init();
 103 }
 104
 105 void AliLevel3::Init(){
 106   fWriteOut = kFALSE;
 107   fGlobalMerger=0;
 108   fTransformer = new AliL3Transform();
 109   fDoRoi = kFALSE;
 110   fUseBinary =kFALSE;
 111   SetPath("");
 112   fFindVertex =kTRUE;
 113   fNPatch = 5;   //number of patches change row in process
 114   fVertexFinder = new AliL3VertexFinder();
 115   fVertex = new AliL3Vertex();
 116   fTracker = new AliL3ConfMapper();
 117   fTrackMerger = new AliL3TrackMerger(fNPatch);
 118   fInterMerger = new AliL3InterMerger();
 119   fFileHandler = new AliL3MemHandler();
 120   fBenchmark = new AliL3Benchmark();
 121 }
 122
 123 void AliLevel3::DoBench(char* name){
 124   fBenchmark->Analyze(name);
 125 }
 126
 127 void AliLevel3::DoMc(char* file){
 128 }
 129
 130 AliLevel3::~AliLevel3(){
 131   //Destructor
 132   if(fVertexFinder)  delete fVertexFinder;
 133   if(fVertex)  delete fVertex;
 134   if(fTracker) delete fTracker;
 135   if(fTransformer) delete fTransformer;
 136   if(fTrackMerger) delete fTrackMerger;
 137   if(fInterMerger) delete fInterMerger;
 138   if(fFileHandler) delete fFileHandler;
 139 }
 140
 141 void AliLevel3::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
 142                                    Int_t trackletlength, Int_t tracklength,
 143                                    Int_t rowscopetracklet, Int_t rowscopetrack,
 144                                    Double_t min_pt_fit, Double_t maxangle,
 145                                    Double_t goodDist, Double_t hitChi2Cut,
 146                                    Double_t goodHitChi2, Double_t trackChi2Cut,
 147                                    Int_t maxdist)
 148 {
 149   //Set parameters input to the tracker
 150   //If no arguments are given, default parameters will be used
 151
 152   fTracker->SetNSegments(phi_segments,eta_segments);
 153   fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
 154   fTracker->SetMaxDca(min_pt_fit);
 155   fTracker->SetTrackletCuts(maxangle,goodDist,true);
 156   fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist);
 157
 158   fTracker->SetParamDone(true);
 159 }
 160
 161 void AliLevel3::ProcessEvent(Int_t first,Int_t last){
 162   //Do tracking on all slices in region [first,last]
 163   //Slices numbering in TPC goes from 0-35, which means that 1 slice
 164   //corresponds to inner+outer sector.E.g. slice 2 corresponds to
 165   //inner=2 + outer=38.
 166   fGlobalMerger= new AliL3GlobalMerger(first,last);
 167   for(Int_t i=first; i<=last; i++){
 168     ProcessSlice(i);
 169     fGlobalMerger->SetVertex(fVertex);
 170     fGlobalMerger->SetTransformer(fTransformer);
 171     fGlobalMerger->InitSlice(i);
 172 //    fBenchmark->Start("Fill Global Merger");
 173     fGlobalMerger->FillTracks(fNTrackData,fTrackData);
 174 //    fBenchmark->Stop("Fill Global Merger");
 175     fFileHandler->Free();   //free the memory
 176     fNTrackData=0;
 177     fTrackData=0;
 178   }
 179   fBenchmark->Start("Global Merger");
 180   fGlobalMerger->Merge();
 181 //  fGlobalMerger->SlowMerge();
 182   fBenchmark->Stop("Global Merger");
 183
 184   if(fWriteOut) WriteResults();
 185   delete fGlobalMerger; fGlobalMerger = 0;
 186 }
 187
 188 void AliLevel3::ProcessSlice(Int_t slice){
 189   char name[256];
 190 //  Int_t row[5][2] = {{ 0,173}};
 191   Int_t row[5][2] = {{ 0, 45},{46,77},{78,109},{110,141},{142,173}};
 192   const Int_t maxpoints=100000;
 193   const Int_t pointsize = maxpoints * sizeof(AliL3SpacePointData);
 194   AliL3MemHandler *memory = new AliL3MemHandler();
 195
 196   fTrackMerger->Reset();
 197   fTrackMerger->SetTransformer(fTransformer);
 198   fTrackMerger->SetRows(row[0]);
 199   for(Int_t patch=fNPatch-1;patch>=0;patch--){
 200     fFileHandler->Init(slice,patch,row[patch]);
 201     fFileHandler->Init(fTransformer);
 202     UInt_t npoints=0;
 203     AliL3SpacePointData *points =0;
 204     UInt_t ndigits=0;
 205     AliL3DigitRowData *digits =0;
 206     if(fUseBinary){
 207
 208       if(!fDoRoi){
 209         if(0){     //Binary to Memory
 210           fFileHandler->Free();
 211           sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
 212           fFileHandler->SetBinaryInput(name);
 213           digits= (AliL3DigitRowData *)fFileHandler->CompBinary2Memory(ndigits);
 214           fFileHandler->CloseBinaryInput();
 215         }
 216
 217         if(1){     //Binary to Memory with Benchmark
 218           fFileHandler->Free();
 219           sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
 220           memory->SetBinaryInput(name);
 221           UInt_t compsize=memory->GetFileSize();
 222           UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
 223           memory->CompBinary2CompMemory(ndigits,comp);
 224           memory->CloseBinaryInput();
 225           UInt_t datasize=memory->GetMemorySize(ndigits,comp);
 226           digits=(AliL3DigitRowData *)fFileHandler->Allocate(datasize);
 227           fBenchmark->Start("Unpacker");
 228           fFileHandler->CompMemory2Memory(ndigits,digits,comp);
 229           fBenchmark->Stop("Unpacker");
 230           memory->Free();
 231         }
 232
 233         if(0){     //Binary to Memory with Random
 234           fFileHandler->Free();
 235           fFileHandler->ResetRandom();
 236           fFileHandler->SetRandomCluster(100);
 237           fFileHandler->SetNGenerate(100);
 238           sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
 239           memory->SetBinaryInput(name);
 240           UInt_t compsize=memory->GetFileSize();
 241           UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
 242           memory->CompBinary2CompMemory(ndigits,comp);
 243           memory->CloseBinaryInput();
 244           UInt_t dsize=memory->GetMemorySize(ndigits,comp);
 245           UInt_t rsize=fFileHandler->GetRandomSize();
 246           digits=(AliL3DigitRowData*)fFileHandler->Allocate(dsize+rsize);
 247           fBenchmark->Start("Unpacker");
 248           fFileHandler->CompMemory2Memory(ndigits,digits,comp);
 249           fBenchmark->Stop("Unpacker");
 250           memory->Free();
 251           if(0)
 252             cerr<<endl<<dsize/1024<<" "<<rsize/1024<<" "
 253                                     <<100.*rsize/dsize<<"%"<<endl;
 254         }
 255       }
 256
 257       else{     //Binary to Memory with Roi
 258         fFileHandler->Free();
 259         Int_t sli[2]={0,0};
 260         fFileHandler->SetROI(fEta,sli);
 261         sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
 262         memory->SetBinaryInput(name);
 263         UInt_t compsize=memory->GetFileSize();
 264         UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
 265         memory->CompBinary2CompMemory(ndigits,comp);
 266         memory->CloseBinaryInput();
 267         UInt_t datasize=memory->GetMemorySize(ndigits,comp);
 268         digits=(AliL3DigitRowData *)fFileHandler->Allocate(datasize);
 269         fBenchmark->Start("Unpacker");
 270         datasize = fFileHandler->CompMemory2Memory(ndigits,digits,comp);
 271         fBenchmark->Stop("Unpacker");
 272         memory->Free();
 273         if(0)
 274          cerr<<endl<<datasize/1024<<" "<<endl;
 275       }
 276
 277
 278       points = (AliL3SpacePointData *) memory->Allocate(pointsize);
 279
 280       fClusterFinder = new AliL3ClustFinder(fTransformer);
 281       fClusterFinder->InitSlice(slice,patch,row[patch][0],row[patch][1]
 282                                                                ,maxpoints);
 283       fClusterFinder->SetXYError(0.1);
 284       fClusterFinder->SetZError(0.2);
 285       fClusterFinder->SetOutputArray(points);
 286 //      fBenchmark->Start("Read Cluster Finder");
 287       fClusterFinder->Read(ndigits,digits);
 288 //      fBenchmark->Stop("Read Cluster Finder");
 289       fBenchmark->Start("Cluster Finder");
 290       fClusterFinder->ProcessDigits();
 291       fBenchmark->Stop("Cluster Finder");
 292       npoints = fClusterFinder->GetNumberOfClusters();
 293       delete fClusterFinder;
 294       fClusterFinder =0;
 295       fFileHandler->Free();
 296
 297     LOG(AliL3Log::kInformational,"AliLevel3::ProcessSlice","Cluster Finder")
 298       <<AliL3Log::kDec<<"Found "<<npoints<<" Points"<<ENDLOG;
 299     }
 300
 301     else{
 302
 303     }
 304
 305     if(patch == fNPatch-1){
 306       // Vertex
 307       if(fFindVertex){
 308       // Vertex Finder
 309
 310         fBenchmark->Start("Vertex Finder Read");
 311         fVertexFinder->Reset();
 312         fVertexFinder->Read(npoints,points);
 313         fBenchmark->Stop("Vertex Finder Read");
 314         fBenchmark->Start("Vertex Finder");
 315
 316         fVertexFinder->Analyze();
 317         AliL3VertexData vertex[1];
 318         fVertexFinder->Write(vertex);
 319         fVertex->Read(vertex);
 320         fBenchmark->Stop("Vertex Finder");
 321       }
 322       else{
 323         //use 0,0,0 for vertex
 324         fVertex->SetZero();
 325       }
 326       fTrackMerger->SetVertex(fVertex);
 327     }
 328     fTracker->InitSector(slice,row[patch]);
 329     fTracker->SetVertex(fVertex);
 330     fBenchmark->Start("Tracker Read Hits");
 331     fTracker->ReadHits(npoints,points);
 332     fBenchmark->Stop("Tracker Read Hits");
 333     fBenchmark->Start("MainVertexTracking A");
 334     fTracker->MainVertexTracking_a();
 335     fBenchmark->Stop("MainVertexTracking A");
 336     fBenchmark->Start("MainVertexTracking B");
 337     fTracker->MainVertexTracking_b();
 338     fBenchmark->Stop("MainVertexTracking B");
 339     fBenchmark->Start("Tracking fit");
 340     fTracker->FillTracks();
 341     fBenchmark->Stop("Tracking fit");
 342
 343     if(fWriteOut)
 344        WriteSpacePoints(npoints, points, slice, patch); //do after Tracking
 345     fFileHandler->Free();
 346
 347     UInt_t ntracks0 =0;
 348     AliL3TrackSegmentData *trackdata0  =
 349          (AliL3TrackSegmentData *) memory->Allocate(fTracker->GetTracks());
 350     memory->TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
 351
 352     //write tracks
 353     if(fWriteOut){
 354       sprintf(name,"tracks_tr_%d_%d.raw",slice,patch);
 355       memory->SetBinaryOutput(name);
 356       memory->Memory2Binary(ntracks0,trackdata0);
 357       memory->CloseBinaryOutput();
 358     }
 359
 360     fInterMerger->Reset();
 361     fInterMerger->SetTransformer(fTransformer);
 362     fInterMerger->Init(row[patch],patch);
 363
 364 //    fBenchmark->Start("Fill Inter Merger");
 365     fInterMerger->FillTracks(ntracks0,trackdata0);
 366 //    fBenchmark->Stop("Fill Inter Merger");
 367     fBenchmark->Start("Inter Merger");
 368     fInterMerger->Merge();
 369 //    fInterMerger->SlowMerge();
 370
 371     fBenchmark->Stop("Inter Merger");
 372
 373     //write inter merged tracks
 374     if(fWriteOut){
 375       sprintf(name,"tracks_im_%d_%d.raw",slice,patch);
 376       WriteTracks(name,fInterMerger,'i'); //write output of intermerger
 377     }
 378     memory->Free();
 379
 380     UInt_t ntracks1 =0;
 381     AliL3TrackSegmentData *trackdata1 =
 382       (AliL3TrackSegmentData *) memory->Allocate(fInterMerger->GetInTracks(0));
 383     memory->TrackArray2Memory(ntracks1,trackdata1,fInterMerger->GetInTracks(0));
 384
 385     fTrackMerger->InitSector(slice,patch);
 386 //    fBenchmark->Start("Fill Patch Merger");
 387     fTrackMerger->FillTracks(ntracks1,trackdata1);
 388 //    fBenchmark->Stop("Fill Patch Merger");
 389
 390     memory->Free();
 391   }
 392   fBenchmark->Start("Patch Merger");
 393 //  fTrackMerger->SlowMerge();
 394   fTrackMerger->Merge();
 395   fBenchmark->Stop("Patch Merger");
 396   //write merged tracks
 397   if(fWriteOut){
 398     sprintf(name,"tracks_tm_%d.raw",slice);
 399     WriteTracks(name,fTrackMerger,'o'); //write output of trackmerger
 400   }
 401
 402   fTrackData = (AliL3TrackSegmentData *)
 403                          fFileHandler->Allocate(fTrackMerger->GetOutTracks());
 404
 405   fFileHandler->TrackArray2Memory(fNTrackData,fTrackData,
 406                                                 fTrackMerger->GetOutTracks());
 407
 408   delete memory;
 409 }
 410
 411 void AliLevel3::WriteSpacePoints(UInt_t npoints,AliL3SpacePointData *points,
 412                                                       Int_t slice,Int_t patch){
 413   char name[256];
 414   sprintf(name,"points_%d_%d.raw",slice,patch);
 415   AliL3MemHandler * memory = new AliL3MemHandler();
 416   memory->SetBinaryOutput(name);
 417   memory->Transform(npoints,points,slice,fTransformer);
 418   memory->Memory2Binary(npoints,points);
 419   memory->CloseBinaryOutput();
 420   delete  memory;
 421 }
 422
 423
 424 Int_t AliLevel3::WriteTracks(char *filename,AliL3Merger *merger,char opt){
 425   AliL3MemHandler *memory = new AliL3MemHandler();
 426   memory->SetBinaryOutput(filename);
 427   if(opt=='a'||opt=='i'){  //add intracks
 428     for(Int_t i=0;i<merger->GetNIn();i++){
 429       AliL3TrackArray *tr=merger->GetInTracks(i);
 430       memory->TrackArray2Binary(tr);
 431     }
 432   }
 433
 434   if(opt=='o'||opt=='a'){
 435     AliL3TrackArray *tr=merger->GetOutTracks();
 436     memory->TrackArray2Binary(tr);
 437   }
 438
 439   memory->CloseBinaryOutput();
 440
 441   return 1;
 442 }
 443
 444 void AliLevel3::WriteResults()
 445 {
 446   //Write the resulting tracks to outputfile
 447   WriteTracks("tracks.raw",fGlobalMerger,'a');
 448 }