3 // Author: Anders Vestbo <mailto:vestbo$fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
4 //*-- Copyright © ASV
7 #include <TDirectory.h>
8 #include <TClonesArray.h>
9 #include <TStopwatch.h>
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"
28 #include "AliL3FileHandler.h"
30 #include "AliL3Benchmark.h"
32 #include "AliL3DigitData.h"
33 #include "AliL3TrackSegmentData.h"
34 #include "AliL3SpacePointData.h"
35 #include "AliL3VertexData.h"
37 //_____________________________________________________________
41 // Interface class for Level3 tracker.
42 // Tracking is done by calling constructor with input,output
44 // You must always remember to set the tracking parameters. E.g.:
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)
51 <img src="tpcsectorsnb.gif">
57 AliLevel3::AliLevel3()
62 AliLevel3::AliLevel3(Char_t *infile)
64 //Constructor. Calls constructor of the tracker, vertexfinder and merger classes.
66 fInputFile = new TFile(infile,"READ");
68 if(!fInputFile->IsOpen())
70 LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
71 <<"Inputfile "<<infile<<" does not exist"<<ENDLOG;
77 AliLevel3::AliLevel3(TFile *in)
81 LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
82 <<"Pointer to InFile 0x0!"<<ENDLOG;
86 if(!fInputFile->IsOpen())
88 LOG(AliL3Log::kError,"AliLevel3::AliLevel3","File Open")
89 <<"Inputfile does not exist"<<ENDLOG;
94 void AliLevel3::Init(Char_t *path,Bool_t binary=kTRUE,Int_t npatches=6)
96 if(!binary && !fInputFile)
98 LOG(AliL3Log::kError,"AliLevel3::Init","Files")
99 <<"You have not supplied the input rootfile; use the appropriate ctor!"<<ENDLOG;
104 fTransformer = new AliL3Transform(path);
106 fDoNonVertex = kFALSE;
107 fClusterDeconv = kTRUE;
117 fNPatch = 1; //number of patches change row in process
118 fRow[0][0] = 0; // first row
119 fRow[0][1] = 175; // last row
122 fNPatch = 2; //number of patches change row in process
123 fRow[0][0] = 0; // first row
126 fRow[1][1] = 175; // last row
129 fNPatch = 5; //number of patches change row in process
130 fRow[0][0] = 0; // first row
139 fRow[4][1] = 175; // last row
142 fNPatch = 6; //number of patches change row in process
143 fRow[0][0] = 0; // first row
154 fRow[5][1] = 175; // last row
157 fVertexFinder = new AliL3VertexFinder();
158 fVertex = new AliL3Vertex();
159 fTracker = new AliL3ConfMapper();
160 fTrackMerger = new AliL3TrackMerger(fNPatch);
161 fInterMerger = new AliL3InterMerger();
163 fFileHandler = new AliL3FileHandler();
164 fFileHandler->SetAliInput(fInputFile);
166 fFileHandler = new AliL3MemHandler();
168 fBenchmark = new AliL3Benchmark();
171 void AliLevel3::DoBench(char* name){
172 fBenchmark->Analyze(name);
175 void AliLevel3::DoMc(char* file){
177 if(!fFileHandler->IsDigit())
178 fFileHandler->SetMCOutput(file);
182 AliLevel3::~AliLevel3(){
184 if(fVertexFinder) delete fVertexFinder;
185 if(fVertex) delete fVertex;
186 if(fTracker) delete fTracker;
187 if(fTransformer) delete fTransformer;
188 if(fTrackMerger) delete fTrackMerger;
189 if(fInterMerger) delete fInterMerger;
190 if(fFileHandler) delete fFileHandler;
193 void AliLevel3::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
194 Int_t trackletlength, Int_t tracklength,
195 Int_t rowscopetracklet, Int_t rowscopetrack,
196 Double_t min_pt_fit, Double_t maxangle,
197 Double_t goodDist, Double_t hitChi2Cut,
198 Double_t goodHitChi2, Double_t trackChi2Cut,
199 Int_t maxdist,Double_t maxphi,Double_t maxeta,Bool_t vertexconstraint)
201 //Set parameters input to the tracker
202 //If no arguments are given, default parameters will be used
204 fTracker->SetNSegments(phi_segments,eta_segments);
205 fTracker->SetMaxDca(min_pt_fit);
206 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexconstraint);
207 fTracker->SetTrackletCuts(maxangle,goodDist,vertexconstraint);
209 fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack,maxphi,maxeta);
211 fTracker->NonVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
213 fTracker->SetParamDone(true);
214 fTracker->InitVolumes();
217 void AliLevel3::ProcessEvent(Int_t first,Int_t last,Int_t event){
218 //Do tracking on all slices in region [first,last]
219 //Slices numbering in TPC goes from 0-35, which means that 1 slice
220 //corresponds to inner+outer sector.E.g. slice 2 corresponds to
221 //inner=2 + outer=38.
222 fGlobalMerger= new AliL3GlobalMerger(first,last);
224 for(Int_t i=first; i<=last; i++){
226 fGlobalMerger->SetVertex(fVertex);
227 fGlobalMerger->SetTransformer(fTransformer);
228 fGlobalMerger->InitSlice(i);
229 fGlobalMerger->FillTracks(fNTrackData,fTrackData);
230 fFileHandler->Free(); //free the memory
234 fBenchmark->Start("Global Merger");
235 //fGlobalMerger->AddAllTracks();
236 //fGlobalMerger->Merge();
237 fGlobalMerger->SlowMerge();
238 fBenchmark->Stop("Global Merger");
240 if(fWriteOut) WriteResults();
241 delete fGlobalMerger; fGlobalMerger = 0;
244 void AliLevel3::ProcessSlice(Int_t slice){
246 Bool_t UseCF = kFALSE;
248 UseCF = fFileHandler->IsDigit();
251 UseCF = kTRUE; //In case you are not using aliroot
253 const Int_t maxpoints=100000;
254 const Int_t pointsize = maxpoints * sizeof(AliL3SpacePointData);
255 AliL3MemHandler *memory = new AliL3MemHandler();
257 fTrackMerger->Reset();
258 fTrackMerger->SetTransformer(fTransformer);
259 fTrackMerger->SetRows(fRow[0]);
260 for(Int_t patch=fNPatch-1;patch>=0;patch--){
261 fFileHandler->Init(slice,patch,fRow[patch]);
262 fFileHandler->Init(fTransformer);
264 AliL3SpacePointData *points =0;
266 AliL3DigitRowData *digits =0;
270 if(1){ //Binary to Memory
271 fFileHandler->Free();
272 sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
273 if(!fFileHandler->SetBinaryInput(name)) return;
274 digits= (AliL3DigitRowData *)fFileHandler->CompBinary2Memory(ndigits);
275 fFileHandler->CloseBinaryInput();
278 if(0){ //Binary to Memory with Benchmark
279 fFileHandler->Free();
280 sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
281 if(!memory->SetBinaryInput(name)) return;
282 UInt_t compsize=memory->GetFileSize();
283 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
284 memory->CompBinary2CompMemory(ndigits,comp);
285 memory->CloseBinaryInput();
286 UInt_t datasize=memory->GetMemorySize(ndigits,comp);
287 digits=(AliL3DigitRowData *)fFileHandler->Allocate(datasize);
288 fBenchmark->Start("Unpacker");
289 fFileHandler->CompMemory2Memory(ndigits,digits,comp);
290 fBenchmark->Stop("Unpacker");
294 if(0){ //Binary to Memory with Random
295 fFileHandler->Free();
296 fFileHandler->ResetRandom();
297 fFileHandler->SetRandomCluster(100);
298 fFileHandler->SetNGenerate(100);
299 sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
300 if(!memory->SetBinaryInput(name)) return;
301 UInt_t compsize=memory->GetFileSize();
302 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
303 memory->CompBinary2CompMemory(ndigits,comp);
304 memory->CloseBinaryInput();
305 UInt_t dsize=memory->GetMemorySize(ndigits,comp);
306 UInt_t rsize=fFileHandler->GetRandomSize();
307 digits=(AliL3DigitRowData*)fFileHandler->Allocate(dsize+rsize);
308 fBenchmark->Start("Unpacker");
309 fFileHandler->CompMemory2Memory(ndigits,digits,comp);
310 fBenchmark->Stop("Unpacker");
315 else{ //Binary to Memory with Roi
316 fFileHandler->Free();
318 fFileHandler->SetROI(fEta,sli);
319 sprintf(name,"%sdigits_%d_%d.raw",fPath,slice,patch);
320 if(!memory->SetBinaryInput(name)) return;
321 UInt_t compsize=memory->GetFileSize();
322 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
323 memory->CompBinary2CompMemory(ndigits,comp);
324 memory->CloseBinaryInput();
325 UInt_t datasize=memory->GetMemorySize(ndigits,comp);
326 digits=(AliL3DigitRowData *)fFileHandler->Allocate(datasize);
327 fBenchmark->Start("Unpacker");
328 datasize = fFileHandler->CompMemory2Memory(ndigits,digits,comp);
329 fBenchmark->Stop("Unpacker");
335 fBenchmark->Start("Dummy Unpacker");
336 sprintf(name,"digits_%d_%d.raw",slice,patch);
337 fBenchmark->Stop("Dummy Unpacker");
339 if(0){ //Ali to Binary
340 fFileHandler->SetBinaryOutput(name);
341 fFileHandler->AliDigits2CompBinary();
342 fFileHandler->CloseBinaryOutput();
345 if(1){ //Ali to Memory
346 digits=(AliL3DigitRowData *)fFileHandler->AliDigits2Memory(ndigits,fEvent);
347 if(fWriteOut){ //Memory to Binary
348 fFileHandler->SetBinaryOutput(name);
349 fFileHandler->Memory2CompBinary(ndigits,digits);
350 fFileHandler->CloseBinaryOutput();
354 }//end else UseBinary
356 points = (AliL3SpacePointData *) memory->Allocate(pointsize);
358 fClusterFinder = new AliL3ClustFinderNew(fTransformer);
359 fClusterFinder->InitSlice(slice,patch,fRow[patch][0],fRow[patch][1]
361 fClusterFinder->SetDeconv(fClusterDeconv);
362 fClusterFinder->SetXYError(0.2);
363 fClusterFinder->SetZError(0.3);
364 fClusterFinder->SetOutputArray(points);
365 fClusterFinder->Read(ndigits,digits);
366 fBenchmark->Start("Cluster Finder");
367 fClusterFinder->ProcessDigits();
368 fBenchmark->Stop("Cluster Finder");
369 npoints = fClusterFinder->GetNumberOfClusters();
370 delete fClusterFinder;
372 fFileHandler->Free();
373 LOG(AliL3Log::kInformational,"AliLevel3::ProcessSlice","Cluster Finder")
374 <<AliL3Log::kDec<<"Found "<<npoints<<" Points"<<ENDLOG;
378 else{// if not use Clusterfinder
379 if(fUseBinary){//Binary to Memory
381 sprintf(name,"/%spoints_%d_%d.raw",fPath,slice,patch);
382 if(!memory->SetBinaryInput(name)) return;
383 points = (AliL3SpacePointData *) memory->Allocate();
384 memory->Binary2Memory(npoints,points);
385 memory->CloseBinaryInput();
386 LOG(AliL3Log::kInformational,"AliLevel3::ProcessSlice","Read Cluster")
387 <<AliL3Log::kDec<<"Found "<<npoints<<" Points in File"<<ENDLOG;
391 points = fFileHandler->AliPoints2Memory(npoints);
394 fBenchmark->Start("Dummy Unpacker");
395 fBenchmark->Stop("Dummy Unpacker");
396 fBenchmark->Start("Dummy CF");
397 fBenchmark->Stop("Dummy CF");
400 if(patch == fNPatch-1){
405 fBenchmark->Start("Vertex Finder Read");
406 fVertexFinder->Reset();
407 fVertexFinder->Read(npoints,points);
408 fBenchmark->Stop("Vertex Finder Read");
409 fBenchmark->Start("Vertex Finder");
410 fVertexFinder->Analyze();
411 AliL3VertexData vertex[1];
412 fVertexFinder->Write(vertex);
413 fVertex->Read(vertex);
414 fBenchmark->Stop("Vertex Finder");
417 //use 0,0,0 for vertex
420 fTrackMerger->SetVertex(fVertex);
422 fTracker->InitSector(slice,fRow[patch]);//,fEta);
423 fTracker->SetVertex(fVertex);
424 fBenchmark->Start("Tracker Read Hits");
425 fTracker->ReadHits(npoints,points);
426 fBenchmark->Stop("Tracker Read Hits");
427 fBenchmark->Start("MainVertexTracking A");
428 fTracker->MainVertexTracking();
429 //fTracker->MainVertexTracking_a();
430 fBenchmark->Stop("MainVertexTracking A");
431 //fBenchmark->Start("MainVertexTracking B");
432 //fTracker->MainVertexTracking_b();
433 //fBenchmark->Stop("MainVertexTracking B");
434 fBenchmark->Start("Tracking fit");
436 fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
437 fTracker->FillTracks();
438 fBenchmark->Stop("Tracking fit");
441 WriteSpacePoints(npoints, points, slice, patch); //do after Tracking
447 fFileHandler->Free();
450 AliL3TrackSegmentData *trackdata0 =
451 (AliL3TrackSegmentData *) memory->Allocate(fTracker->GetTracks());
452 memory->TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
456 sprintf(name,"%stracks_tr_%d_%d.raw",fWriteOutPath,slice,patch);
457 memory->SetBinaryOutput(name);
458 memory->Memory2Binary(ntracks0,trackdata0);
459 memory->CloseBinaryOutput();
462 fInterMerger->Reset();
463 fInterMerger->SetTransformer(fTransformer);
464 fInterMerger->Init(fRow[patch],patch);
466 fInterMerger->FillTracks(ntracks0,trackdata0);
467 fBenchmark->Start("Inter Merger");
468 // fInterMerger->Merge();
469 // fInterMerger->SlowMerge();
471 fBenchmark->Stop("Inter Merger");
473 //write inter merged tracks
475 sprintf(name,"%stracks_im_%d_%d.raw",fWriteOutPath,slice,patch);
476 WriteTracks(name,fInterMerger,'i'); //write output of intermerger
482 AliL3TrackSegmentData *trackdata1 =
483 (AliL3TrackSegmentData *) memory->Allocate(fInterMerger->GetInTracks(0));
484 memory->TrackArray2Memory(ntracks1,trackdata1,fInterMerger->GetInTracks(0));
486 fTrackMerger->InitSector(slice,patch);
487 fTrackMerger->FillTracks(ntracks1,trackdata1);
491 fBenchmark->Start("Patch Merger");
492 // fTrackMerger->SlowMerge();
493 //fTrackMerger->AddAllTracks();
494 fTrackMerger->Merge();
495 fBenchmark->Stop("Patch Merger");
497 //write merged tracks
499 sprintf(name,"%stracks_tm_%d.raw",fWriteOutPath,slice);
500 WriteTracks(name,fTrackMerger,'o'); //write output of trackmerger
503 fTrackData = (AliL3TrackSegmentData *)
504 fFileHandler->Allocate(fTrackMerger->GetOutTracks());
506 fFileHandler->TrackArray2Memory(fNTrackData,fTrackData,
507 fTrackMerger->GetOutTracks());
512 void AliLevel3::WriteSpacePoints(UInt_t npoints,AliL3SpacePointData *points,
513 Int_t slice,Int_t patch){
515 sprintf(name,"%spoints_%d_%d.raw",fWriteOutPath,slice,patch);
516 AliL3MemHandler * memory = new AliL3MemHandler();
517 memory->SetBinaryOutput(name);
518 memory->Transform(npoints,points,slice,fTransformer);
519 memory->Memory2Binary(npoints,points);
520 memory->CloseBinaryOutput();
525 Int_t AliLevel3::WriteTracks(char *filename,AliL3Merger *merger,char opt){
526 AliL3MemHandler *memory = new AliL3MemHandler();
527 memory->SetBinaryOutput(filename);
528 if(opt=='a'||opt=='i'){ //add intracks
529 for(Int_t i=0;i<merger->GetNIn();i++){
530 AliL3TrackArray *tr=merger->GetInTracks(i);
531 memory->TrackArray2Binary(tr);
535 if(opt=='o'||opt=='a'){
536 AliL3TrackArray *tr=merger->GetOutTracks();
537 memory->TrackArray2Binary(tr);
540 memory->CloseBinaryOutput();
545 void AliLevel3::WriteResults()
547 //Write the resulting tracks to outputfile
549 sprintf(fname,"%stracks.raw",fWriteOutPath);
550 WriteTracks(fname,fGlobalMerger,'a');
551 //WriteTracks("tracks.raw",fGlobalMerger,'a');
552 sprintf(fname,"%stracks_gl.raw",fWriteOutPath);
553 WriteTracks(fname,fGlobalMerger,'o');
554 //WriteTracks("tracks_gl.raw",fGlobalMerger,'o');