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