]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HLT/TPCLib/AliHLTTPC.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cleanup (Gaute)
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPC.cxx
CommitLineData
a6c02c85 1// @(#) $Id$
c2f37813 2// Original: AliLevel3.cxx,v 1.42 2004/06/11 16:06:33 loizides
a6c02c85 3
4// Author: Anders Vestbo <mailto:vestbo@fi.uib.no>, Uli Frankenfeld <mailto:franken@fi.uib.no>
5//*-- Copyright &copy ALICE HLT Group
6
a6c02c85 7#ifndef no_root
8#include <TFile.h>
9#include <TDirectory.h>
10#include <TClonesArray.h>
11#include <TStopwatch.h>
12#endif
13
a6c02c85 14#include <AliRunLoader.h>
a6c02c85 15
16#include "AliHLTTPCLogging.h"
17#include "AliHLTTPC.h"
18#include "AliHLTTPCConfMapper.h"
19#include "AliHLTTPCVertex.h"
20#include "AliHLTTPCVertexFinder.h"
21#include "AliHLTTPCTrackMerger.h"
22#include "AliHLTTPCGlobalMerger.h"
23#include "AliHLTTPCInterMerger.h"
24#include "AliHLTTPCConfMapPoint.h"
25#include "AliHLTTPCConfMapTrack.h"
26#include "AliHLTTPCTransform.h"
a38a7850 27#include "AliHLTTPCClusterFinder.h"
28#include "AliHLTTPCDigitReaderUnpacked.h"
a6c02c85 29#include "AliHLTTPCDigitData.h"
30#include "AliHLTTPCTrackArray.h"
31#include "AliHLTTPCMemHandler.h"
32#include "AliHLTTPCFitter.h"
a6c02c85 33#include "AliHLTTPCFileHandler.h"
a6c02c85 34#include "AliHLTTPCBenchmark.h"
35#include "AliHLTTPCDigitData.h"
36#include "AliHLTTPCTrackSegmentData.h"
37#include "AliHLTTPCSpacePointData.h"
38#include "AliHLTTPCVertexData.h"
e419b223 39//#include "AliHLTTPCDDLDataFileHandler.h"
a6c02c85 40
41/** \class AliHLTTPC
42<pre>
43//_____________________________________________________________
44//
45// AliHLTTPC
46//
47// Interface class for HLTTPC tracker.
48// For example how to use, see exa/runtracker.C (root)
49// or programs/runtracker.cxx (standalone program).
50//Begin_Html
51//<img src="tpcsectorsnb.gif">
52//End_Html
53</pre>
54*/
55
56ClassImp(AliHLTTPC)
57
a6c02c85 58AliHLTTPC::AliHLTTPC()
59{
60 //Default constructor. Should also be used when input is from binary files.
61 //In that case the path to where the binary files are located has to be
62 //passed to the AliLevel::Init function.
63
64 fVertexFinder=0;
65 fVertex=0;
66 fTracker=0;
67 fTrackMerger=0;
68 fInterMerger=0;
69 fFileHandler=0;
70 fGlobalMerger=0;
71 fInputFile=0;
a6c02c85 72 fRunLoader=0;
a6c02c85 73}
74
75AliHLTTPC::AliHLTTPC(Char_t *infile)
76{
77 //Constructor to use for when input is anything else but binary files,
78 //meaning rootfiles or raw files.
79
80 fVertexFinder=0;
81 fVertex=0;
82 fTracker=0;
83 fTrackMerger=0;
84 fInterMerger=0;
85 fFileHandler=0;
86 fGlobalMerger=0;
87 fInputFile = infile;
a6c02c85 88 fRunLoader=0;
a6c02c85 89}
90
a6c02c85 91AliHLTTPC::AliHLTTPC(AliRunLoader *rl)
92{
93 //Constructor to use when input is aliroot runloader
94 fVertexFinder=0;
95 fVertex=0;
96 fTracker=0;
97 fTrackMerger=0;
98 fInterMerger=0;
99 fFileHandler=0;
100 fGlobalMerger=0;
101 fInputFile=0;
102 fRunLoader = rl;
103}
a6c02c85 104
600e6a1b 105Bool_t AliHLTTPC::fgDoVertexFit = kTRUE;//Include the vertex in the final track fit
106
a6c02c85 107void AliHLTTPC::Init(Char_t *path,EFileType filetype,Int_t npatches)
108{
109 //Init the whole standard tracker chain
a6c02c85 110
111 if((filetype!=kBinary) && (filetype!=kDate)
112 && (filetype!=kRunLoader)&& !fInputFile)
113 {
114 LOG(AliHLTTPCLog::kError,"AliHLTTPC::Init","Files")
115 <<"You have not supplied the input rootfile; use the appropriate ctor!"<<ENDLOG;
116 return;
117 }
a6c02c85 118 if((filetype==kRunLoader) && !fRunLoader)
119 {
120 LOG(AliHLTTPCLog::kError,"AliHLTTPC::Init","Files")
121 <<"You have not supplied the input runloader; use the appropriate ctor!"<<ENDLOG;
122 return;
123 }
a6c02c85 124
125 fWriteOut = kFALSE;
126 fPileUp = kFALSE;
127 fNoCF=kFALSE;
128 fUseBinary = (filetype==kBinary);
129 SetPath(path);
130
131 fDoRoi = kFALSE;
132 fDoNonVertex = kFALSE;
133 fFindVertex = kFALSE;
134 SetClusterFinderParam();
135
136 fEta[0] = 0.;
137 fEta[1] = 1.1;
138
139 fEvent=0;
312160d3 140 /*just to be sure*/
a6c02c85 141 AliHLTTPCFileHandler::CleanStaticIndex();
a6c02c85 142
143 switch(npatches){
144 case 0:
145 fNPatch = 1;
146 fRow[0][0] = AliHLTTPCTransform::GetFirstRow(3);
147 fRow[0][1] = AliHLTTPCTransform::GetLastRow(5);
148 break;
149 case 1:
150 fNPatch = 1; //number of patches change row in process
151 fRow[0][0] = 0;
152 fRow[0][1] = AliHLTTPCTransform::GetLastRow(-1);
153 break;
154 case 2:
155 fNPatch = 2; //number of patches change row in process
156 fRow[0][0] = 0; // first row
157 fRow[0][1] = AliHLTTPCTransform::GetLastRow(1);
158 fRow[1][0] = AliHLTTPCTransform::GetFirstRow(2);
159 fRow[1][1] = AliHLTTPCTransform::GetLastRow(5);
160 break;
161 default:
162 fNPatch = 6;
163 fRow[0][0] = AliHLTTPCTransform::GetFirstRow(0);
164 fRow[0][1] = AliHLTTPCTransform::GetLastRow(0);
165 fRow[1][0] = AliHLTTPCTransform::GetFirstRow(1);
166 fRow[1][1] = AliHLTTPCTransform::GetLastRow(1);
167 fRow[2][0] = AliHLTTPCTransform::GetFirstRow(2);
168 fRow[2][1] = AliHLTTPCTransform::GetLastRow(2);
169 fRow[3][0] = AliHLTTPCTransform::GetFirstRow(3);
170 fRow[3][1] = AliHLTTPCTransform::GetLastRow(3);
171 fRow[4][0] = AliHLTTPCTransform::GetFirstRow(4);
172 fRow[4][1] = AliHLTTPCTransform::GetLastRow(4);
173 fRow[5][0] = AliHLTTPCTransform::GetFirstRow(5);
174 fRow[5][1] = AliHLTTPCTransform::GetLastRow(5);
175 }
176
177 fVertexFinder = new AliHLTTPCVertexFinder();
178 fVertex = new AliHLTTPCVertex();
179 fTracker = new AliHLTTPCConfMapper();
180 fTrackMerger = new AliHLTTPCTrackMerger(fNPatch);
181 fInterMerger = new AliHLTTPCInterMerger();
182 fGlobalMerger = new AliHLTTPCGlobalMerger();
183 SetMergerParameters();//Set default merger parameters
e419b223 184 if(filetype==kRoot){
a6c02c85 185 fFileHandler = new AliHLTTPCFileHandler(kTRUE); //static version
186 fFileHandler->SetAliInput(fInputFile);
187 }else if(filetype==kRaw){
e419b223 188 LOG(AliHLTTPCLog::kFatal,"AliHLTTPC::Init","Files")
189 <<"AliHLTTPCDDLDataFileHandler not available in this build"<<ENDLOG;
190// fFileHandler = new AliHLTTPCDDLDataFileHandler();
191// fFileHandler->SetReaderInput(fInputFile);
a6c02c85 192 }else if(filetype==kDate){
e419b223 193 LOG(AliHLTTPCLog::kFatal,"AliHLTTPC::Init","Files")
194 <<"AliHLTTPCDDLDataFileHandler not available in this build"<<ENDLOG;
195// fFileHandler = new AliHLTTPCDDLDataFileHandler();
196// fFileHandler->SetReaderInput(fInputFile,-1);
a6c02c85 197 }
a6c02c85 198 else if(filetype==kRunLoader){
199 fFileHandler = new AliHLTTPCFileHandler(kTRUE); //static version
200 fFileHandler->SetAliInput(fRunLoader);
201 }
a6c02c85 202 else{
203 fFileHandler = new AliHLTTPCMemHandler();
204 }
a6c02c85 205 fBenchmark = new AliHLTTPCBenchmark();
206}
207
208void AliHLTTPC::DoBench(char* name)
209{
210 //dobench
211 fBenchmark->Analyze(name);
212 delete fBenchmark;
213 fBenchmark = new AliHLTTPCBenchmark();
214}
215
216void AliHLTTPC::DoMc(char* file)
217{
218 //domc
a6c02c85 219 if(!fFileHandler->IsDigit(fEvent))
220 fFileHandler->SetMCOutput(file);
a6c02c85 221}
222
223AliHLTTPC::~AliHLTTPC()
224{
225 //Destructor
226 if(fVertexFinder) delete fVertexFinder;
227 if(fVertex) delete fVertex;
228 if(fTracker) delete fTracker;
229 if(fTrackMerger) delete fTrackMerger;
230 if(fInterMerger) delete fInterMerger;
231 if(fFileHandler) delete fFileHandler;
232 if(fGlobalMerger) delete fGlobalMerger;
233}
234
235void AliHLTTPC::SetClusterFinderParam(Float_t fXYError, Float_t fZError, Bool_t deconv)
236{
237 //set cluster finder parameter
238 fXYClusterError=fXYError;
239 fZClusterError=fZError;
240 fClusterDeconv=deconv;
241}
242
243void AliHLTTPC::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
244 Int_t trackletlength, Int_t tracklength,
245 Int_t rowscopetracklet, Int_t rowscopetrack,
246 Double_t min_pt_fit, Double_t maxangle,
247 Double_t goodDist, Double_t hitChi2Cut,
248 Double_t goodHitChi2, Double_t trackChi2Cut,
249 Int_t maxdist,Double_t maxphi,Double_t maxeta,
250 Bool_t vertexconstraint)
251{
252 //Set parameters input to the tracker
253 //If no arguments are given, default parameters will be used
254
255 fTracker->SetNSegments(phi_segments,eta_segments);
256 fTracker->SetMaxDca(min_pt_fit);
257 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexconstraint);
258 fTracker->SetTrackletCuts(maxangle,goodDist,vertexconstraint);
259 if(vertexconstraint)
260 fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack,maxphi,maxeta);
261 else
262 fTracker->NonVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
263 fTracker->InitVolumes();
264}
265
266void AliHLTTPC::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
267{
268 //set global merger parameter
269 fGlobalMerger->SetParameter(maxy,maxz,maxkappa,maxpsi,maxtgl);
270}
271
272void AliHLTTPC::ProcessEvent(Int_t first,Int_t last,Int_t event)
273{
274 //Do tracking on all slices in region [first,last]
275 //Slices numbering in TPC goes from 0-35, which means that one slice
276 //corresponds to inner+outer sector.E.g. slice 2 corresponds to
277 //inner=2 + outer=38.
278
279 fGlobalMerger->Setup(first,last);
a6c02c85 280 if(fEvent!=event) AliHLTTPCFileHandler::CleanStaticIndex();
a6c02c85 281 fEvent=event;
282 for(Int_t i=first; i<=last; i++){
283 ProcessSlice(i);
284 fGlobalMerger->SetVertex(fVertex);
285 fGlobalMerger->InitSlice(i);
286 fGlobalMerger->FillTracks(fNTrackData,fTrackData);
287 fFileHandler->Free(); //free the memory
288 fNTrackData=0;
289 fTrackData=0;
290 }
291 fBenchmark->Start("Global track merger");
292 //fGlobalMerger->AddAllTracks();
293 fGlobalMerger->Merge();
294 //fGlobalMerger->SlowMerge(fWriteOutPath);
295 fBenchmark->Stop("Global track merger");
296
297 FitGlobalTracks();
298
299 if(fWriteOut) WriteResults();
300 fFileHandler->FreeDigitsTree();
301}
302
303void AliHLTTPC::ProcessSlice(Int_t slice)
304{
305 //process slice
306 char name[256];
307 Bool_t UseCF = kFALSE;
a6c02c85 308 UseCF = fFileHandler->IsDigit(fEvent);
a6c02c85 309 if(fUseBinary)
310 UseCF = kTRUE; //In case you are not using aliroot
311 if(fNoCF == kTRUE) //In case you don't want to run with cluster finder
312 UseCF = kFALSE;
313
314 const Int_t kmaxpoints=120000;
315 const Int_t kpointsize = kmaxpoints * sizeof(AliHLTTPCSpacePointData);
316 AliHLTTPCMemHandler *memory = new AliHLTTPCMemHandler();
317
318 fTrackMerger->Reset();
319 fTrackMerger->SetRows(fRow[0]);
320
321 for(Int_t patch=fNPatch-1;patch>=0;patch--){
322 fFileHandler->Init(slice,patch,&fRow[patch][0]);
323 UInt_t npoints=0;
324 AliHLTTPCSpacePointData *points =0;
325 UInt_t ndigits=0;
326 AliHLTTPCDigitRowData *digits =0;
a38a7850 327 UInt_t digitSize = 0;
a6c02c85 328 if(UseCF){
a38a7850 329 if(fUseBinary) {
330 if(!fDoRoi) {
a6c02c85 331 if(1){ //Binary to Memory
332 fFileHandler->Free();
333 if(fNPatch == 1)
334 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
335 else
336 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
337 if(!fFileHandler->SetBinaryInput(name)) return;
338 if(fPileUp)
339 { //Read binary files which are not RLE
340 digits = (AliHLTTPCDigitRowData*)fFileHandler->Allocate();
a38a7850 341 fFileHandler->Binary2Memory(ndigits,digits, digitSize );
342 digitSize = fFileHandler->GetFileSize();
a6c02c85 343 }
344 else //Read RLE binary files
a38a7850 345 {
346 digits= (AliHLTTPCDigitRowData *)fFileHandler->CompBinary2Memory(ndigits, digitSize);
347 }
a6c02c85 348
349 fFileHandler->CloseBinaryInput();
350 }
351
352 if(0){ //Binary to Memory with Benchmark
353 fFileHandler->Free();
354 if(fNPatch == 1)
355 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
356 else
357 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
358 if(!memory->SetBinaryInput(name)) return;
359 UInt_t compsize=memory->GetFileSize();
360 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
361 memory->CompBinary2CompMemory(ndigits,comp);
362 memory->CloseBinaryInput();
363 UInt_t datasize=memory->GetMemorySize(ndigits,comp);
364 digits=(AliHLTTPCDigitRowData *)fFileHandler->Allocate(datasize);
365 fBenchmark->Start("Unpacker");
a38a7850 366 fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize);
a6c02c85 367 fBenchmark->Stop("Unpacker");
368 memory->Free();
369 }
370
371 if(0){ //Binary to Memory with Random
372 fFileHandler->Free();
373 fFileHandler->ResetRandom();
374 fFileHandler->SetRandomCluster(100);
375 fFileHandler->SetNGenerate(100);
376 if(fNPatch == 1)
377 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
378 else
379 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
380 if(!memory->SetBinaryInput(name)) return;
381 UInt_t compsize=memory->GetFileSize();
382 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
383 memory->CompBinary2CompMemory(ndigits,comp);
384 memory->CloseBinaryInput();
385 UInt_t dsize=memory->GetMemorySize(ndigits,comp);
386 UInt_t rsize=fFileHandler->GetRandomSize();
387 digits=(AliHLTTPCDigitRowData*)fFileHandler->Allocate(dsize+rsize);
388 fBenchmark->Start("Unpacker");
a38a7850 389 fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize);
a6c02c85 390 fBenchmark->Stop("Unpacker");
391 memory->Free();
392 }
393 }
394
395 else{ //Binary to Memory with Roi
396 fFileHandler->Free();
397 Int_t sli[2]={0,0};
398 fFileHandler->SetROI(fEta,sli);
399 if(fNPatch==1)
400 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
401 else
402 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
403 if(!memory->SetBinaryInput(name)) return;
404 UInt_t compsize=memory->GetFileSize();
405 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
406 memory->CompBinary2CompMemory(ndigits,comp);
407 memory->CloseBinaryInput();
408 UInt_t datasize=memory->GetMemorySize(ndigits,comp);
409 digits=(AliHLTTPCDigitRowData *)fFileHandler->Allocate(datasize);
410 fBenchmark->Start("Unpacker");
a38a7850 411 datasize = fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize);
a6c02c85 412 fBenchmark->Stop("Unpacker");
413 memory->Free();
414 }
415 }//end UseBinary
416 else{
a6c02c85 417 fBenchmark->Start("Dummy Unpacker");
418 if(fNPatch==1)
419 sprintf(name,"digits_%d_%d_%d.raw",fEvent,slice,-1);
420 else
421 sprintf(name,"digits_%d_%d_%d.raw",fEvent,slice,patch);
422 fBenchmark->Stop("Dummy Unpacker");
423
424 if(0){ //Ali to Binary
425 fFileHandler->SetBinaryOutput(name);
426 fFileHandler->AliDigits2CompBinary();
427 fFileHandler->CloseBinaryOutput();
428 }
429
430 if(1){ //Ali to Memory
431 digits=(AliHLTTPCDigitRowData *)fFileHandler->AliAltroDigits2Memory(ndigits,fEvent);
432 if(0){ //Memory to Binary
433 fFileHandler->SetBinaryOutput(name);
434 fFileHandler->Memory2CompBinary(ndigits,digits);
435 fFileHandler->CloseBinaryOutput();
436 }
437 }
a6c02c85 438 }//end else UseBinary
439
440 points = (AliHLTTPCSpacePointData *) memory->Allocate(kpointsize);
a38a7850 441 fClusterFinder = new AliHLTTPCClusterFinder();
442 fDigitReader = new AliHLTTPCDigitReaderUnpacked();
a6c02c85 443 fClusterFinder->InitSlice(slice,patch,fRow[patch][0],fRow[patch][1],kmaxpoints);
444 fClusterFinder->SetDeconv(fClusterDeconv);
445 fClusterFinder->SetXYError(fXYClusterError);
446 fClusterFinder->SetZError(fZClusterError);
447 if((fXYClusterError>0)&&(fZClusterError>0))
448 fClusterFinder->SetCalcErr(kFALSE);
449 fClusterFinder->SetOutputArray(points);
a38a7850 450 fClusterFinder->SetReader( fDigitReader );
a6c02c85 451 fBenchmark->Start("Cluster finder");
a38a7850 452 //fClusterFinder->Read(ndigits,digits);
453 fClusterFinder->Read( (void*)digits, (unsigned long) digitSize );
a6c02c85 454 fClusterFinder->ProcessDigits();
455 fBenchmark->Stop("Cluster finder");
456 npoints = fClusterFinder->GetNumberOfClusters();
457 delete fClusterFinder;
458 fClusterFinder = 0;
459 fFileHandler->Free();
460 LOG(AliHLTTPCLog::kInformational,"AliHLTTPC::ProcessSlice","Cluster Finder")
461 <<AliHLTTPCLog::kDec<<"Found "<<npoints<<" Points"<<ENDLOG;
462 }//end UseCF
463 else{// if not use Clusterfinder
464 if(fUseBinary){//Binary to Memory
465 memory->Free();
466 if(fNPatch==1)
467 sprintf(name,"%s/points_%d_%d_%d.raw",fPath,fEvent,slice,-1);
468 else
469 sprintf(name,"%s/points_%d_%d_%d.raw",fPath,fEvent,slice,patch);
470 if(!memory->SetBinaryInput(name)) return;
471 points = (AliHLTTPCSpacePointData *) memory->Allocate();
472 memory->Binary2Memory(npoints,points);
473 memory->CloseBinaryInput();
474 LOG(AliHLTTPCLog::kInformational,"AliHLTTPC::ProcessSlice","Read Cluster")
475 <<AliHLTTPCLog::kDec<<"Found "<<npoints<<" Points in File"<<ENDLOG;
476 }
a6c02c85 477 else{
478 points = fFileHandler->AliPoints2Memory(npoints);
479 }
a6c02c85 480 fBenchmark->Start("Dummy Unpacker");
481 fBenchmark->Stop("Dummy Unpacker");
482 fBenchmark->Start("Dummy CF");
483 fBenchmark->Stop("Dummy CF");
484 }
485
486 if(patch == fNPatch-1){
487 // Vertex
488 if(fFindVertex){
489 // Vertex Finder
490
491 fBenchmark->Start("Vertex Finder Read");
492 fVertexFinder->Reset();
493 fVertexFinder->Read(npoints,points);
494 fBenchmark->Stop("Vertex Finder Read");
495 fBenchmark->Start("Vertex Finder");
496 fVertexFinder->Analyze();
497 AliHLTTPCVertexData vertex[1];
498 fVertexFinder->Write(vertex);
499 fVertex->Read(vertex);
500 fBenchmark->Stop("Vertex Finder");
501 }
502 else{
503 //use 0,0,0 for vertex
504 fVertex->SetZero();
505 }
506 fTrackMerger->SetVertex(fVertex);
507 }
508
509 fTracker->InitSector(slice,fRow[patch],fEta);
510 fTracker->SetVertex(fVertex);
511 fBenchmark->Start("Tracker setup");
512 fTracker->ReadHits(npoints,points);
513 fTracker->MainVertexTracking_a();
514 fBenchmark->Stop("Tracker setup");
515 fBenchmark->Start("Track follower");
516 fTracker->MainVertexTracking_b();
517 fBenchmark->Stop("Track follower");
518 if(fDoNonVertex)
519 fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
520 fBenchmark->Start("Sector track fitting");
521 fTracker->FillTracks();
522 fBenchmark->Stop("Sector track fitting");
523
524 if(fWriteOut)
525 WriteSpacePoints(npoints, points, slice, patch); //do after Tracking
526
527 //free memory
528 if(UseCF)
529 memory->Free();
530 else
531 fFileHandler->Free();
532
533 UInt_t ntracks0 =0;
534 AliHLTTPCTrackSegmentData *trackdata0 =
535 (AliHLTTPCTrackSegmentData *) memory->Allocate(fTracker->GetTracks());
536 memory->TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
537
538 //write tracks
539 if(fWriteOut){
540 if(fNPatch==1)
541 sprintf(name,"%s/tracks_tr_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,-1);
542 else
543 sprintf(name,"%s/tracks_tr_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,patch);
544 memory->SetBinaryOutput(name);
545 memory->Memory2Binary(ntracks0,trackdata0);
546 memory->CloseBinaryOutput();
547 }
548
549 fInterMerger->Reset();
550 fInterMerger->Init(fRow[patch],patch);
551
552 fInterMerger->FillTracks(ntracks0,trackdata0);
553
554 //fBenchmark->Start("Inter Merger");
555 // fInterMerger->Merge();
556 // fInterMerger->SlowMerge();
557
558 //fBenchmark->Stop("Inter Merger");
559 /*
560 //write inter merged tracks
561 if(fWriteOut){
562 sprintf(name,"%stracks_im_%d_%d.raw",fWriteOutPath,slice,patch);
563 WriteTracks(name,fInterMerger,'i'); //write output of intermerger
564 }
565 */
566 memory->Free();
567
568 UInt_t ntracks1 =0;
569 AliHLTTPCTrackSegmentData *trackdata1 =
570 (AliHLTTPCTrackSegmentData *) memory->Allocate(fInterMerger->GetInTracks(0));
571 memory->TrackArray2Memory(ntracks1,trackdata1,fInterMerger->GetInTracks(0));
572
573 fTrackMerger->InitSector(slice,patch);
574 fTrackMerger->FillTracks(ntracks1,trackdata1);
575
576 memory->Free();
577 }
578 //fBenchmark->Start("Patch Merger");
579 //fTrackMerger->SlowMerge();
580 fTrackMerger->AddAllTracks();
581 //fTrackMerger->Merge();
582 //fBenchmark->Stop("Patch Merger");
583 /*
584 //write merged tracks
585 if(fWriteOut){
586 sprintf(name,"%stracks_tm_%d.raw",fWriteOutPath,slice);
587 WriteTracks(name,fTrackMerger,'o'); //write output of trackmerger
588 }
589 */
590 fTrackData = (AliHLTTPCTrackSegmentData *)
591 fFileHandler->Allocate(fTrackMerger->GetOutTracks());
592
593 fFileHandler->TrackArray2Memory(fNTrackData,fTrackData,
594 fTrackMerger->GetOutTracks());
595
596 delete memory;
597}
598
599void AliHLTTPC::FitGlobalTracks()
600{
601 //fit global tracks
602 AliHLTTPCFitter *fitter = new AliHLTTPCFitter(fVertex,AliHLTTPC::DoVertexFit());
603 if(fNPatch==1)
604 fitter->LoadClusters(fWriteOutPath,fEvent,kTRUE);
605 else
606 fitter->LoadClusters(fWriteOutPath,fEvent,kFALSE);
607
608 fBenchmark->Start("Global track fitter");
609 AliHLTTPCTrackArray *tracks = fGlobalMerger->GetOutTracks();
610 for(Int_t i=0; i<tracks->GetNTracks(); i++)
611 {
612 AliHLTTPCTrack *tr = tracks->GetCheckedTrack(i);
613 if(!tr) continue;
614 fitter->FitHelix(tr);
615 tr->UpdateToFirstPoint();
616 }
617 fBenchmark->Stop("Global track fitter");
618 delete fitter;
619}
620
621void AliHLTTPC::WriteSpacePoints(UInt_t npoints,AliHLTTPCSpacePointData *points,
622 Int_t slice,Int_t patch) const
623{
624 //write space points
625 char name[256];
626 if(fNPatch==1)
627 sprintf(name,"%s/points_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,-1);
628 else
629 sprintf(name,"%s/points_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,patch);
630 AliHLTTPCMemHandler * memory = new AliHLTTPCMemHandler();
631 memory->SetBinaryOutput(name);
632 memory->Transform(npoints,points,slice);
633 memory->Memory2Binary(npoints,points);
634 memory->CloseBinaryOutput();
635 delete memory;
636}
637
638Int_t AliHLTTPC::WriteTracks(char *filename,AliHLTTPCMerger *merger,char opt) const
639{
640 //write tracks
641 AliHLTTPCMemHandler *memory = new AliHLTTPCMemHandler();
642 memory->SetBinaryOutput(filename);
643 if(opt=='a'||opt=='i'){ //add intracks
644 for(Int_t i=0;i<merger->GetNIn();i++){
645 AliHLTTPCTrackArray *tr=merger->GetInTracks(i);
646 memory->TrackArray2Binary(tr);
647 }
648 }
649
650 if(opt=='o'||opt=='a'){
651 AliHLTTPCTrackArray *tr=merger->GetOutTracks();
652 memory->TrackArray2Binary(tr);
653 }
654
655 memory->CloseBinaryOutput();
656 delete memory;
657 return 1;
658}
659
660void AliHLTTPC::WriteResults()
661{
662 //Write the resulting tracks to outputfile
663 Char_t fname[256];
664 sprintf(fname,"%s/tracks_%d.raw",fWriteOutPath,fEvent);
665 WriteTracks(fname,fGlobalMerger,'a');
666 //WriteTracks("tracks.raw",fGlobalMerger,'a');
667 sprintf(fname,"%s/tracks_gl_%d.raw",fWriteOutPath,fEvent);
668 WriteTracks(fname,fGlobalMerger,'o');
669 //WriteTracks("tracks_gl.raw",fGlobalMerger,'o');
670}