HLT/src/AliLevel3.cxx

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