HLT/src/AliLevel3.cxx

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