]> 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
just removing dead wood
[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"
39#include "AliHLTTPCDDLDataFileHandler.h"
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
a6c02c85 184 if(filetype==kRoot){
185 fFileHandler = new AliHLTTPCFileHandler(kTRUE); //static version
186 fFileHandler->SetAliInput(fInputFile);
187 }else if(filetype==kRaw){
188 fFileHandler = new AliHLTTPCDDLDataFileHandler();
189 fFileHandler->SetReaderInput(fInputFile);
190 }else if(filetype==kDate){
191 fFileHandler = new AliHLTTPCDDLDataFileHandler();
192 fFileHandler->SetReaderInput(fInputFile,-1);
193 }
a6c02c85 194 else if(filetype==kRunLoader){
195 fFileHandler = new AliHLTTPCFileHandler(kTRUE); //static version
196 fFileHandler->SetAliInput(fRunLoader);
197 }
a6c02c85 198 else{
199 fFileHandler = new AliHLTTPCMemHandler();
200 }
a6c02c85 201 fBenchmark = new AliHLTTPCBenchmark();
202}
203
204void AliHLTTPC::DoBench(char* name)
205{
206 //dobench
207 fBenchmark->Analyze(name);
208 delete fBenchmark;
209 fBenchmark = new AliHLTTPCBenchmark();
210}
211
212void AliHLTTPC::DoMc(char* file)
213{
214 //domc
a6c02c85 215 if(!fFileHandler->IsDigit(fEvent))
216 fFileHandler->SetMCOutput(file);
a6c02c85 217}
218
219AliHLTTPC::~AliHLTTPC()
220{
221 //Destructor
222 if(fVertexFinder) delete fVertexFinder;
223 if(fVertex) delete fVertex;
224 if(fTracker) delete fTracker;
225 if(fTrackMerger) delete fTrackMerger;
226 if(fInterMerger) delete fInterMerger;
227 if(fFileHandler) delete fFileHandler;
228 if(fGlobalMerger) delete fGlobalMerger;
229}
230
231void AliHLTTPC::SetClusterFinderParam(Float_t fXYError, Float_t fZError, Bool_t deconv)
232{
233 //set cluster finder parameter
234 fXYClusterError=fXYError;
235 fZClusterError=fZError;
236 fClusterDeconv=deconv;
237}
238
239void AliHLTTPC::SetTrackerParam(Int_t phi_segments, Int_t eta_segments,
240 Int_t trackletlength, Int_t tracklength,
241 Int_t rowscopetracklet, Int_t rowscopetrack,
242 Double_t min_pt_fit, Double_t maxangle,
243 Double_t goodDist, Double_t hitChi2Cut,
244 Double_t goodHitChi2, Double_t trackChi2Cut,
245 Int_t maxdist,Double_t maxphi,Double_t maxeta,
246 Bool_t vertexconstraint)
247{
248 //Set parameters input to the tracker
249 //If no arguments are given, default parameters will be used
250
251 fTracker->SetNSegments(phi_segments,eta_segments);
252 fTracker->SetMaxDca(min_pt_fit);
253 fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,vertexconstraint);
254 fTracker->SetTrackletCuts(maxangle,goodDist,vertexconstraint);
255 if(vertexconstraint)
256 fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack,maxphi,maxeta);
257 else
258 fTracker->NonVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack);
259 fTracker->InitVolumes();
260}
261
262void AliHLTTPC::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
263{
264 //set global merger parameter
265 fGlobalMerger->SetParameter(maxy,maxz,maxkappa,maxpsi,maxtgl);
266}
267
268void AliHLTTPC::ProcessEvent(Int_t first,Int_t last,Int_t event)
269{
270 //Do tracking on all slices in region [first,last]
271 //Slices numbering in TPC goes from 0-35, which means that one slice
272 //corresponds to inner+outer sector.E.g. slice 2 corresponds to
273 //inner=2 + outer=38.
274
275 fGlobalMerger->Setup(first,last);
a6c02c85 276 if(fEvent!=event) AliHLTTPCFileHandler::CleanStaticIndex();
a6c02c85 277 fEvent=event;
278 for(Int_t i=first; i<=last; i++){
279 ProcessSlice(i);
280 fGlobalMerger->SetVertex(fVertex);
281 fGlobalMerger->InitSlice(i);
282 fGlobalMerger->FillTracks(fNTrackData,fTrackData);
283 fFileHandler->Free(); //free the memory
284 fNTrackData=0;
285 fTrackData=0;
286 }
287 fBenchmark->Start("Global track merger");
288 //fGlobalMerger->AddAllTracks();
289 fGlobalMerger->Merge();
290 //fGlobalMerger->SlowMerge(fWriteOutPath);
291 fBenchmark->Stop("Global track merger");
292
293 FitGlobalTracks();
294
295 if(fWriteOut) WriteResults();
296 fFileHandler->FreeDigitsTree();
297}
298
299void AliHLTTPC::ProcessSlice(Int_t slice)
300{
301 //process slice
302 char name[256];
303 Bool_t UseCF = kFALSE;
a6c02c85 304 UseCF = fFileHandler->IsDigit(fEvent);
a6c02c85 305 if(fUseBinary)
306 UseCF = kTRUE; //In case you are not using aliroot
307 if(fNoCF == kTRUE) //In case you don't want to run with cluster finder
308 UseCF = kFALSE;
309
310 const Int_t kmaxpoints=120000;
311 const Int_t kpointsize = kmaxpoints * sizeof(AliHLTTPCSpacePointData);
312 AliHLTTPCMemHandler *memory = new AliHLTTPCMemHandler();
313
314 fTrackMerger->Reset();
315 fTrackMerger->SetRows(fRow[0]);
316
317 for(Int_t patch=fNPatch-1;patch>=0;patch--){
318 fFileHandler->Init(slice,patch,&fRow[patch][0]);
319 UInt_t npoints=0;
320 AliHLTTPCSpacePointData *points =0;
321 UInt_t ndigits=0;
322 AliHLTTPCDigitRowData *digits =0;
a38a7850 323 UInt_t digitSize = 0;
a6c02c85 324 if(UseCF){
a38a7850 325 if(fUseBinary) {
326 if(!fDoRoi) {
a6c02c85 327 if(1){ //Binary to Memory
328 fFileHandler->Free();
329 if(fNPatch == 1)
330 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
331 else
332 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
333 if(!fFileHandler->SetBinaryInput(name)) return;
334 if(fPileUp)
335 { //Read binary files which are not RLE
336 digits = (AliHLTTPCDigitRowData*)fFileHandler->Allocate();
a38a7850 337 fFileHandler->Binary2Memory(ndigits,digits, digitSize );
338 digitSize = fFileHandler->GetFileSize();
a6c02c85 339 }
340 else //Read RLE binary files
a38a7850 341 {
342 digits= (AliHLTTPCDigitRowData *)fFileHandler->CompBinary2Memory(ndigits, digitSize);
343 }
a6c02c85 344
345 fFileHandler->CloseBinaryInput();
346 }
347
348 if(0){ //Binary to Memory with Benchmark
349 fFileHandler->Free();
350 if(fNPatch == 1)
351 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
352 else
353 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
354 if(!memory->SetBinaryInput(name)) return;
355 UInt_t compsize=memory->GetFileSize();
356 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
357 memory->CompBinary2CompMemory(ndigits,comp);
358 memory->CloseBinaryInput();
359 UInt_t datasize=memory->GetMemorySize(ndigits,comp);
360 digits=(AliHLTTPCDigitRowData *)fFileHandler->Allocate(datasize);
361 fBenchmark->Start("Unpacker");
a38a7850 362 fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize);
a6c02c85 363 fBenchmark->Stop("Unpacker");
364 memory->Free();
365 }
366
367 if(0){ //Binary to Memory with Random
368 fFileHandler->Free();
369 fFileHandler->ResetRandom();
370 fFileHandler->SetRandomCluster(100);
371 fFileHandler->SetNGenerate(100);
372 if(fNPatch == 1)
373 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
374 else
375 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
376 if(!memory->SetBinaryInput(name)) return;
377 UInt_t compsize=memory->GetFileSize();
378 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
379 memory->CompBinary2CompMemory(ndigits,comp);
380 memory->CloseBinaryInput();
381 UInt_t dsize=memory->GetMemorySize(ndigits,comp);
382 UInt_t rsize=fFileHandler->GetRandomSize();
383 digits=(AliHLTTPCDigitRowData*)fFileHandler->Allocate(dsize+rsize);
384 fBenchmark->Start("Unpacker");
a38a7850 385 fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize);
a6c02c85 386 fBenchmark->Stop("Unpacker");
387 memory->Free();
388 }
389 }
390
391 else{ //Binary to Memory with Roi
392 fFileHandler->Free();
393 Int_t sli[2]={0,0};
394 fFileHandler->SetROI(fEta,sli);
395 if(fNPatch==1)
396 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,-1);
397 else
398 sprintf(name,"%sdigits_%d_%d_%d.raw",fPath,fEvent,slice,patch);
399 if(!memory->SetBinaryInput(name)) return;
400 UInt_t compsize=memory->GetFileSize();
401 UInt_t *comp=(UInt_t *)memory->Allocate(compsize);
402 memory->CompBinary2CompMemory(ndigits,comp);
403 memory->CloseBinaryInput();
404 UInt_t datasize=memory->GetMemorySize(ndigits,comp);
405 digits=(AliHLTTPCDigitRowData *)fFileHandler->Allocate(datasize);
406 fBenchmark->Start("Unpacker");
a38a7850 407 datasize = fFileHandler->CompMemory2Memory(ndigits,digits,comp,digitSize);
a6c02c85 408 fBenchmark->Stop("Unpacker");
409 memory->Free();
410 }
411 }//end UseBinary
412 else{
a6c02c85 413 fBenchmark->Start("Dummy Unpacker");
414 if(fNPatch==1)
415 sprintf(name,"digits_%d_%d_%d.raw",fEvent,slice,-1);
416 else
417 sprintf(name,"digits_%d_%d_%d.raw",fEvent,slice,patch);
418 fBenchmark->Stop("Dummy Unpacker");
419
420 if(0){ //Ali to Binary
421 fFileHandler->SetBinaryOutput(name);
422 fFileHandler->AliDigits2CompBinary();
423 fFileHandler->CloseBinaryOutput();
424 }
425
426 if(1){ //Ali to Memory
427 digits=(AliHLTTPCDigitRowData *)fFileHandler->AliAltroDigits2Memory(ndigits,fEvent);
428 if(0){ //Memory to Binary
429 fFileHandler->SetBinaryOutput(name);
430 fFileHandler->Memory2CompBinary(ndigits,digits);
431 fFileHandler->CloseBinaryOutput();
432 }
433 }
a6c02c85 434 }//end else UseBinary
435
436 points = (AliHLTTPCSpacePointData *) memory->Allocate(kpointsize);
a38a7850 437 fClusterFinder = new AliHLTTPCClusterFinder();
438 fDigitReader = new AliHLTTPCDigitReaderUnpacked();
a6c02c85 439 fClusterFinder->InitSlice(slice,patch,fRow[patch][0],fRow[patch][1],kmaxpoints);
440 fClusterFinder->SetDeconv(fClusterDeconv);
441 fClusterFinder->SetXYError(fXYClusterError);
442 fClusterFinder->SetZError(fZClusterError);
443 if((fXYClusterError>0)&&(fZClusterError>0))
444 fClusterFinder->SetCalcErr(kFALSE);
445 fClusterFinder->SetOutputArray(points);
a38a7850 446 fClusterFinder->SetReader( fDigitReader );
a6c02c85 447 fBenchmark->Start("Cluster finder");
a38a7850 448 //fClusterFinder->Read(ndigits,digits);
449 fClusterFinder->Read( (void*)digits, (unsigned long) digitSize );
a6c02c85 450 fClusterFinder->ProcessDigits();
451 fBenchmark->Stop("Cluster finder");
452 npoints = fClusterFinder->GetNumberOfClusters();
453 delete fClusterFinder;
454 fClusterFinder = 0;
455 fFileHandler->Free();
456 LOG(AliHLTTPCLog::kInformational,"AliHLTTPC::ProcessSlice","Cluster Finder")
457 <<AliHLTTPCLog::kDec<<"Found "<<npoints<<" Points"<<ENDLOG;
458 }//end UseCF
459 else{// if not use Clusterfinder
460 if(fUseBinary){//Binary to Memory
461 memory->Free();
462 if(fNPatch==1)
463 sprintf(name,"%s/points_%d_%d_%d.raw",fPath,fEvent,slice,-1);
464 else
465 sprintf(name,"%s/points_%d_%d_%d.raw",fPath,fEvent,slice,patch);
466 if(!memory->SetBinaryInput(name)) return;
467 points = (AliHLTTPCSpacePointData *) memory->Allocate();
468 memory->Binary2Memory(npoints,points);
469 memory->CloseBinaryInput();
470 LOG(AliHLTTPCLog::kInformational,"AliHLTTPC::ProcessSlice","Read Cluster")
471 <<AliHLTTPCLog::kDec<<"Found "<<npoints<<" Points in File"<<ENDLOG;
472 }
a6c02c85 473 else{
474 points = fFileHandler->AliPoints2Memory(npoints);
475 }
a6c02c85 476 fBenchmark->Start("Dummy Unpacker");
477 fBenchmark->Stop("Dummy Unpacker");
478 fBenchmark->Start("Dummy CF");
479 fBenchmark->Stop("Dummy CF");
480 }
481
482 if(patch == fNPatch-1){
483 // Vertex
484 if(fFindVertex){
485 // Vertex Finder
486
487 fBenchmark->Start("Vertex Finder Read");
488 fVertexFinder->Reset();
489 fVertexFinder->Read(npoints,points);
490 fBenchmark->Stop("Vertex Finder Read");
491 fBenchmark->Start("Vertex Finder");
492 fVertexFinder->Analyze();
493 AliHLTTPCVertexData vertex[1];
494 fVertexFinder->Write(vertex);
495 fVertex->Read(vertex);
496 fBenchmark->Stop("Vertex Finder");
497 }
498 else{
499 //use 0,0,0 for vertex
500 fVertex->SetZero();
501 }
502 fTrackMerger->SetVertex(fVertex);
503 }
504
505 fTracker->InitSector(slice,fRow[patch],fEta);
506 fTracker->SetVertex(fVertex);
507 fBenchmark->Start("Tracker setup");
508 fTracker->ReadHits(npoints,points);
509 fTracker->MainVertexTracking_a();
510 fBenchmark->Stop("Tracker setup");
511 fBenchmark->Start("Track follower");
512 fTracker->MainVertexTracking_b();
513 fBenchmark->Stop("Track follower");
514 if(fDoNonVertex)
515 fTracker->NonVertexTracking();//Do a second pass for nonvertex tracks
516 fBenchmark->Start("Sector track fitting");
517 fTracker->FillTracks();
518 fBenchmark->Stop("Sector track fitting");
519
520 if(fWriteOut)
521 WriteSpacePoints(npoints, points, slice, patch); //do after Tracking
522
523 //free memory
524 if(UseCF)
525 memory->Free();
526 else
527 fFileHandler->Free();
528
529 UInt_t ntracks0 =0;
530 AliHLTTPCTrackSegmentData *trackdata0 =
531 (AliHLTTPCTrackSegmentData *) memory->Allocate(fTracker->GetTracks());
532 memory->TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks());
533
534 //write tracks
535 if(fWriteOut){
536 if(fNPatch==1)
537 sprintf(name,"%s/tracks_tr_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,-1);
538 else
539 sprintf(name,"%s/tracks_tr_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,patch);
540 memory->SetBinaryOutput(name);
541 memory->Memory2Binary(ntracks0,trackdata0);
542 memory->CloseBinaryOutput();
543 }
544
545 fInterMerger->Reset();
546 fInterMerger->Init(fRow[patch],patch);
547
548 fInterMerger->FillTracks(ntracks0,trackdata0);
549
550 //fBenchmark->Start("Inter Merger");
551 // fInterMerger->Merge();
552 // fInterMerger->SlowMerge();
553
554 //fBenchmark->Stop("Inter Merger");
555 /*
556 //write inter merged tracks
557 if(fWriteOut){
558 sprintf(name,"%stracks_im_%d_%d.raw",fWriteOutPath,slice,patch);
559 WriteTracks(name,fInterMerger,'i'); //write output of intermerger
560 }
561 */
562 memory->Free();
563
564 UInt_t ntracks1 =0;
565 AliHLTTPCTrackSegmentData *trackdata1 =
566 (AliHLTTPCTrackSegmentData *) memory->Allocate(fInterMerger->GetInTracks(0));
567 memory->TrackArray2Memory(ntracks1,trackdata1,fInterMerger->GetInTracks(0));
568
569 fTrackMerger->InitSector(slice,patch);
570 fTrackMerger->FillTracks(ntracks1,trackdata1);
571
572 memory->Free();
573 }
574 //fBenchmark->Start("Patch Merger");
575 //fTrackMerger->SlowMerge();
576 fTrackMerger->AddAllTracks();
577 //fTrackMerger->Merge();
578 //fBenchmark->Stop("Patch Merger");
579 /*
580 //write merged tracks
581 if(fWriteOut){
582 sprintf(name,"%stracks_tm_%d.raw",fWriteOutPath,slice);
583 WriteTracks(name,fTrackMerger,'o'); //write output of trackmerger
584 }
585 */
586 fTrackData = (AliHLTTPCTrackSegmentData *)
587 fFileHandler->Allocate(fTrackMerger->GetOutTracks());
588
589 fFileHandler->TrackArray2Memory(fNTrackData,fTrackData,
590 fTrackMerger->GetOutTracks());
591
592 delete memory;
593}
594
595void AliHLTTPC::FitGlobalTracks()
596{
597 //fit global tracks
598 AliHLTTPCFitter *fitter = new AliHLTTPCFitter(fVertex,AliHLTTPC::DoVertexFit());
599 if(fNPatch==1)
600 fitter->LoadClusters(fWriteOutPath,fEvent,kTRUE);
601 else
602 fitter->LoadClusters(fWriteOutPath,fEvent,kFALSE);
603
604 fBenchmark->Start("Global track fitter");
605 AliHLTTPCTrackArray *tracks = fGlobalMerger->GetOutTracks();
606 for(Int_t i=0; i<tracks->GetNTracks(); i++)
607 {
608 AliHLTTPCTrack *tr = tracks->GetCheckedTrack(i);
609 if(!tr) continue;
610 fitter->FitHelix(tr);
611 tr->UpdateToFirstPoint();
612 }
613 fBenchmark->Stop("Global track fitter");
614 delete fitter;
615}
616
617void AliHLTTPC::WriteSpacePoints(UInt_t npoints,AliHLTTPCSpacePointData *points,
618 Int_t slice,Int_t patch) const
619{
620 //write space points
621 char name[256];
622 if(fNPatch==1)
623 sprintf(name,"%s/points_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,-1);
624 else
625 sprintf(name,"%s/points_%d_%d_%d.raw",fWriteOutPath,fEvent,slice,patch);
626 AliHLTTPCMemHandler * memory = new AliHLTTPCMemHandler();
627 memory->SetBinaryOutput(name);
628 memory->Transform(npoints,points,slice);
629 memory->Memory2Binary(npoints,points);
630 memory->CloseBinaryOutput();
631 delete memory;
632}
633
634Int_t AliHLTTPC::WriteTracks(char *filename,AliHLTTPCMerger *merger,char opt) const
635{
636 //write tracks
637 AliHLTTPCMemHandler *memory = new AliHLTTPCMemHandler();
638 memory->SetBinaryOutput(filename);
639 if(opt=='a'||opt=='i'){ //add intracks
640 for(Int_t i=0;i<merger->GetNIn();i++){
641 AliHLTTPCTrackArray *tr=merger->GetInTracks(i);
642 memory->TrackArray2Binary(tr);
643 }
644 }
645
646 if(opt=='o'||opt=='a'){
647 AliHLTTPCTrackArray *tr=merger->GetOutTracks();
648 memory->TrackArray2Binary(tr);
649 }
650
651 memory->CloseBinaryOutput();
652 delete memory;
653 return 1;
654}
655
656void AliHLTTPC::WriteResults()
657{
658 //Write the resulting tracks to outputfile
659 Char_t fname[256];
660 sprintf(fname,"%s/tracks_%d.raw",fWriteOutPath,fEvent);
661 WriteTracks(fname,fGlobalMerger,'a');
662 //WriteTracks("tracks.raw",fGlobalMerger,'a');
663 sprintf(fname,"%s/tracks_gl_%d.raw",fWriteOutPath,fEvent);
664 WriteTracks(fname,fGlobalMerger,'o');
665 //WriteTracks("tracks_gl.raw",fGlobalMerger,'o');
666}