]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HLT/TPCLib/AliHLTTPCFileHandler.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
effC++ and warnings
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCFileHandler.cxx
CommitLineData
a6c02c85 1// @(#) $Id$
4aa41877 2// Original: AliHLTFileHandler.cxx,v 1.49 2005/06/23 17:46:55 hristov
a6c02c85 3
4// Author: Uli Frankenfeld <mailto:franken@fi.uib.no>, Anders Vestbo <mailto:vestbo$fi.uib.no>, C. Loizides <mailto:loizides@ikf.uni-frankfurt.de>
5//*-- Copyright &copy ALICE HLT Group
6
a6c02c85 7#include <TClonesArray.h>
8#include <TSystem.h>
9#include <TMath.h>
10
a6c02c85 11#include <AliRunLoader.h>
95d48915 12#include <TObject.h>
13#include <TFile.h>
14#include <TTree.h>
a6c02c85 15#include <AliTPCParamSR.h>
16#include <AliTPCDigitsArray.h>
17#include <AliTPCClustersArray.h>
18#include <AliTPCcluster.h>
19#include <AliTPCClustersRow.h>
20#include <AliSimDigits.h>
21
22#include "AliHLTTPCLogging.h"
23#include "AliHLTTPCTransform.h"
a6c02c85 24#include "AliHLTTPCDigitData.h"
95d48915 25//#include "AliHLTTPCTrackSegmentData.h"
a6c02c85 26#include "AliHLTTPCSpacePointData.h"
95d48915 27//#include "AliHLTTPCTrackArray.h"
a6c02c85 28#include "AliHLTTPCFileHandler.h"
29
30#if __GNUC__ >= 3
31using namespace std;
32#endif
33
34/** \class AliHLTTPCFileHandler
35<pre>
36//_____________________________________________________________
37// AliHLTTPCFileHandler
38//
39// The HLT ROOT <-> binary files handling class
40//
41// This class provides the interface between AliROOT files,
42// and HLT binary files. It should be used for converting
43// TPC data stored in AliROOT format (outputfile from a simulation),
44// into the data format currently used by in the HLT framework.
45// This enables the possibility to always use the same data format,
46// whether you are using a binary file as an input, or a AliROOT file.
47//
48// For example on how to create binary files from a AliROOT simulation,
49// see example macro exa/Binary.C.
50//
51// For reading a AliROOT file into HLT format in memory, do the following:
52//
53// AliHLTTPCFileHandler file;
54// file.Init(slice,patch);
55// file.SetAliInput("galice.root");
56// AliHLTTPCDigitRowData *dataPt = (AliHLTTPCDigitRowData*)file.AliDigits2Memory(nrows,eventnr);
57//
58// All the data are then stored in memory and accessible via the pointer dataPt.
59// Accesing the data is then identical to the example 1) showed in AliHLTTPCMemHandler class.
60//
61// For converting the data back, and writing it to a new AliROOT file do:
62//
63// AliHLTTPCFileHandler file;
64// file.Init(slice,patch);
65// file.SetAliInput("galice.root");
66// file.Init(slice,patch,NumberOfRowsInPatch);
67// file.AliDigits2RootFile(dataPt,"new_galice.root");
68// file.CloseAliInput();
69</pre>
70*/
71
72ClassImp(AliHLTTPCFileHandler)
73
600e6a1b 74AliHLTTPCFileHandler::AliHLTTPCFileHandler(Bool_t b)
75 :
76 fInAli(NULL),
600e6a1b 77 fUseRunLoader(kFALSE),
600e6a1b 78 fParam(NULL),
600e6a1b 79 fDigits(NULL),
80 fDigitsTree(NULL),
2a083ac4 81 fMC(NULL),
600e6a1b 82 fIndexCreated(kFALSE),
83 fUseStaticIndex(b)
84{
85 //Default constructor
86
87 for(Int_t i=0;i<AliHLTTPCTransform::GetNSlice();i++)
88 for(Int_t j=0;j<AliHLTTPCTransform::GetNRows();j++)
89 fIndex[i][j]=-1;
90
91 if(fUseStaticIndex&&!fgStaticIndexCreated) CleanStaticIndex();
92}
93
94AliHLTTPCFileHandler::AliHLTTPCFileHandler(const AliHLTTPCFileHandler& ref)
95 :
96 fInAli(NULL),
600e6a1b 97 fUseRunLoader(kFALSE),
600e6a1b 98 fParam(NULL),
600e6a1b 99 fDigits(NULL),
100 fDigitsTree(NULL),
2a083ac4 101 fMC(NULL),
600e6a1b 102 fIndexCreated(kFALSE),
103 fUseStaticIndex(ref.fUseStaticIndex)
104{
105 HLTFatal("copy constructor untested");
106}
107
108AliHLTTPCFileHandler& AliHLTTPCFileHandler::operator=(const AliHLTTPCFileHandler&)
109{
110 HLTFatal("assignment operator untested");
111 return *this;
112}
113
114AliHLTTPCFileHandler::~AliHLTTPCFileHandler()
115{
116 //Destructor
117 if(fMC) CloseMCOutput();
118 FreeDigitsTree();
119 if(fInAli) CloseAliInput();
120}
121
a6c02c85 122// of course on start up the index is not created
123Bool_t AliHLTTPCFileHandler::fgStaticIndexCreated=kFALSE;
124Int_t AliHLTTPCFileHandler::fgStaticIndex[36][159];
125
126void AliHLTTPCFileHandler::CleanStaticIndex()
127{
128 // use this static call to clean static index after
129 // running over one event
130 for(Int_t i=0;i<AliHLTTPCTransform::GetNSlice();i++){
131 for(Int_t j=0;j<AliHLTTPCTransform::GetNRows();j++)
132 fgStaticIndex[i][j]=-1;
133 }
134 fgStaticIndexCreated=kFALSE;
135}
136
137Int_t AliHLTTPCFileHandler::SaveStaticIndex(Char_t *prefix,Int_t event)
138{
139 // use this static call to store static index after
140 if(!fgStaticIndexCreated) return -1;
141
142 Char_t fname[1024];
143 if(prefix)
144 sprintf(fname,"%s-%d.txt",prefix,event);
145 else
146 sprintf(fname,"TPC.Digits.staticindex-%d.txt",event);
147
148 ofstream file(fname,ios::trunc);
149 if(!file.good()) return -1;
150
151 for(Int_t i=0;i<AliHLTTPCTransform::GetNSlice();i++){
152 for(Int_t j=0;j<AliHLTTPCTransform::GetNRows();j++)
153 file << fgStaticIndex[i][j] << " ";
154 file << endl;
155 }
156 file.close();
157 return 0;
158}
159
160Int_t AliHLTTPCFileHandler::LoadStaticIndex(Char_t *prefix,Int_t event)
161{
162 // use this static call to store static index after
163 if(fgStaticIndexCreated){
164 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::LoadStaticIndex","Inxed")
165 <<"Static index already created, will overwrite"<<ENDLOG;
166 CleanStaticIndex();
167 }
168
169 Char_t fname[1024];
170 if(prefix)
171 sprintf(fname,"%s-%d.txt",prefix,event);
172 else
173 sprintf(fname,"TPC.Digits.staticindex-%d.txt",event);
174
175 ifstream file(fname);
176 if(!file.good()) return -1;
177
178 for(Int_t i=0;i<AliHLTTPCTransform::GetNSlice();i++){
179 for(Int_t j=0;j<AliHLTTPCTransform::GetNRows();j++)
180 file >> fgStaticIndex[i][j];
181 }
182 file.close();
183
184 fgStaticIndexCreated=kTRUE;
185 return 0;
186}
187
a6c02c85 188void AliHLTTPCFileHandler::FreeDigitsTree()
189{
190 //free digits tree
191 if(!fDigitsTree)
192 {
193 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandler::FreeDigitsTree()","Pointer")
194 <<"Cannot free digitstree, it is not present"<<ENDLOG;
195 return;
196 }
197 delete fDigits;
198 fDigits=0;
a6c02c85 199 fDigitsTree=0;
200
201 for(Int_t i=0;i<AliHLTTPCTransform::GetNSlice();i++){
202 for(Int_t j=0;j<AliHLTTPCTransform::GetNRows();j++)
203 fIndex[i][j]=-1;
204 }
205 fIndexCreated=kFALSE;
206}
207
208Bool_t AliHLTTPCFileHandler::SetMCOutput(Char_t *name)
209{
210 //set mc input
211 fMC = fopen(name,"w");
212 if(!fMC){
213 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::SetMCOutput","File Open")
214 <<"Pointer to File = 0x0 "<<ENDLOG;
215 return kFALSE;
216 }
217 return kTRUE;
218}
219
220Bool_t AliHLTTPCFileHandler::SetMCOutput(FILE *file)
221{
222 //set mc output
223 fMC = file;
224 if(!fMC){
225 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::SetMCOutput","File Open")
226 <<"Pointer to File = 0x0 "<<ENDLOG;
227 return kFALSE;
228 }
229 return kTRUE;
230}
231
232void AliHLTTPCFileHandler::CloseMCOutput()
233{
234 //close mc output
235 if(!fMC){
236 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::CloseMCOutPut","File Close")
237 <<"Nothing to Close"<<ENDLOG;
238 return;
239 }
240 fclose(fMC);
241 fMC =0;
242}
243
244Bool_t AliHLTTPCFileHandler::SetAliInput()
245{
246 //set ali input
a6c02c85 247 fInAli->CdGAFile();
248 fParam = (AliTPCParam*)gFile->Get("75x40_100x60_150x60");
249 if(!fParam){
250 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::SetAliInput","File")
251 <<"No TPC parameters found in \""<<gFile->GetName()
252 <<"\", creating standard parameters "
253 <<"which might not be what you want!"<<ENDLOG;
254 fParam = new AliTPCParamSR;
255 }
256 if(!fParam){
257 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::SetAliInput","File Open")
258 <<"No AliTPCParam "<<AliHLTTPCTransform::GetParamName()<<" in File "<<gFile->GetName()<<ENDLOG;
259 return kFALSE;
260 }
a6c02c85 261
262 return kTRUE;
263}
264
265Bool_t AliHLTTPCFileHandler::SetAliInput(Char_t *name)
266{
267 //Open the AliROOT file with name.
a6c02c85 268 fInAli= AliRunLoader::Open(name);
a6c02c85 269 if(!fInAli){
270 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::SetAliInput","File Open")
271 <<"Pointer to fInAli = 0x0 "<<ENDLOG;
272 return kFALSE;
273 }
274 return SetAliInput();
275}
276
a6c02c85 277Bool_t AliHLTTPCFileHandler::SetAliInput(AliRunLoader *runLoader)
278{
279 //set ali input as runloader
280 fInAli=runLoader;
281 fUseRunLoader = kTRUE;
282 if(!fInAli){
283 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::SetAliInput","File Open")
284 <<"Pointer to AliRunLoader = 0x0 "<<ENDLOG;
285 return kFALSE;
286 }
287 return SetAliInput();
288}
a6c02c85 289
290void AliHLTTPCFileHandler::CloseAliInput()
291{
292 //close ali input
a6c02c85 293 if(fUseRunLoader) return;
a6c02c85 294 if(!fInAli){
295 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::CloseAliInput","RunLoader")
296 <<"Nothing to Close"<<ENDLOG;
297 return;
298 }
a6c02c85 299
300 delete fInAli;
301 fInAli = 0;
302}
303
304Bool_t AliHLTTPCFileHandler::IsDigit(Int_t event)
305{
306 //Check if there is a TPC digit tree in the current file.
307 //Return kTRUE if tree was found, and kFALSE if not found.
308
309 if(!fInAli){
310 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::IsDigit","File")
311 <<"Pointer to fInAli = 0x0 "<<ENDLOG;
312 return kTRUE; //maybe you are using binary input which is Digits!
313 }
a6c02c85 314 AliLoader* tpcLoader = fInAli->GetLoader("TPCLoader");
315 if(!tpcLoader){
316 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandlerNewIO::IsDigit","File")
317 <<"Pointer to AliLoader for TPC = 0x0 "<<ENDLOG;
318 return kFALSE;
319 }
320 fInAli->GetEvent(event);
321 tpcLoader->LoadDigits();
322 TTree *t=tpcLoader->TreeD();
a6c02c85 323 if(t){
324 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandlerNewIO::IsDigit","File Type")
325 <<"Found Digit Tree -> Use Fast Cluster Finder"<<ENDLOG;
326 return kTRUE;
327 }
328 else{
329 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandlerNewIO::IsDigit","File Type")
330 <<"No Digit Tree -> Use Cluster Tree"<<ENDLOG;
331 return kFALSE;
332 }
333}
334
335///////////////////////////////////////// Digit IO
336Bool_t AliHLTTPCFileHandler::AliDigits2Binary(Int_t event,Bool_t altro)
337{
338 //save alidigits as binary
339 Bool_t out = kTRUE;
340 UInt_t nrow;
341 AliHLTTPCDigitRowData* data = 0;
342 if(altro)
343 data = AliAltroDigits2Memory(nrow,event);
344 else
345 data = AliDigits2Memory(nrow,event);
346 out = Memory2Binary(nrow,data);
347 Free();
348 return out;
349}
350
351Bool_t AliHLTTPCFileHandler::AliDigits2CompBinary(Int_t event,Bool_t altro)
352{
353 //Convert AliROOT TPC data, into HLT data format.
354 //event specifies the event you want in the aliroot file.
355
356 Bool_t out = kTRUE;
357 UInt_t ndigits=0;
358 AliHLTTPCDigitRowData *digits=0;
359 if(altro)
360 digits = AliAltroDigits2Memory(ndigits,event);
361 else
362 digits = AliDigits2Memory(ndigits,event);
363 out = Memory2CompBinary(ndigits,digits);
364 Free();
365 return out;
366}
367
368Bool_t AliHLTTPCFileHandler::CreateIndex()
369{
370 //create the access index or copy from static index
371 fIndexCreated=kFALSE;
372
373 if(!fgStaticIndexCreated || !fUseStaticIndex) { //we have to create index
374 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandler::CreateIndex","Index")
375 <<"Starting to create index, this can take a while."<<ENDLOG;
376
377 for(Int_t n=0; n<fDigitsTree->GetEntries(); n++) {
378 Int_t sector, row;
379 Int_t lslice,lrow;
380 fDigitsTree->GetEvent(n);
381 fParam->AdjustSectorRow(fDigits->GetID(),sector,row);
382 if(!AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row)){
383 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::CreateIndex","Slice/Row")
384 <<AliHLTTPCLog::kDec<<"Index could not be created. Wrong values "
385 <<sector<<" "<<row<<ENDLOG;
386 return kFALSE;
387 }
388 if(fIndex[lslice][lrow]==-1) {
389 fIndex[lslice][lrow]=n;
390 }
391 }
392 if(fUseStaticIndex) { // create static index
393 for(Int_t i=0;i<AliHLTTPCTransform::GetNSlice();i++){
394 for(Int_t j=0;j<AliHLTTPCTransform::GetNRows();j++)
395 fgStaticIndex[i][j]=fIndex[i][j];
396 }
397 fgStaticIndexCreated=kTRUE; //remember that index has been created
398 }
399
400 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandler::CreateIndex","Index")
401 <<"Index successfully created."<<ENDLOG;
402
403 } else if(fUseStaticIndex) { //simply copy static index
404 for(Int_t i=0;i<AliHLTTPCTransform::GetNSlice();i++){
405 for(Int_t j=0;j<AliHLTTPCTransform::GetNRows();j++)
406 fIndex[i][j]=fgStaticIndex[i][j];
407 }
408
409 LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandler::CreateIndex","Index")
410 <<"Index successfully taken from static copy."<<ENDLOG;
411 }
412 fIndexCreated=kTRUE;
413 return kTRUE;
414}
415
416AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int_t event)
417{
418 //Read data from AliROOT file into memory, and store it in the HLT data format.
419 //Returns a pointer to the data.
420
421 AliHLTTPCDigitRowData *data = 0;
422 nrow=0;
423
424 if(!fInAli){
425 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliDigits2Memory","File")
426 <<"No Input avalible: Pointer to fInAli == NULL"<<ENDLOG;
427 return 0;
428 }
429
a6c02c85 430 if(!fDigitsTree)
431 if(!GetDigitsTree(event)) return 0;
432
433 UShort_t dig;
434 Int_t time,pad,sector,row;
435 Int_t lslice,lrow;
436 Int_t nrows=0;
437 Int_t ndigitcount=0;
438 Int_t entries = (Int_t)fDigitsTree->GetEntries();
439 if(entries==0) {
440 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliDigits2Memory","ndigits")
441 <<"No TPC digits (entries==0)!"<<ENDLOG;
442 nrow = (UInt_t)(fRowMax-fRowMin+1);
443 Int_t size = nrow*sizeof(AliHLTTPCDigitRowData);
444 data=(AliHLTTPCDigitRowData*) Allocate(size);
445 AliHLTTPCDigitRowData *tempPt = data;
446 for(Int_t r=fRowMin;r<=fRowMax;r++){
447 tempPt->fRow = r;
448 tempPt->fNDigit = 0;
449 tempPt++;
450 }
451 return data;
452 }
453
454 Int_t * ndigits = new Int_t[fRowMax+1];
455 Float_t xyz[3];
456
457 for(Int_t r=fRowMin;r<=fRowMax;r++){
458 Int_t n=fIndex[fSlice][r];
459 if(n!=-1){ //data on that row
460 fDigitsTree->GetEvent(n);
461 fParam->AdjustSectorRow(fDigits->GetID(),sector,row);
462 AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row);
463
464 if(lrow!=r){
465 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliDigits2Memory","Row")
466 <<AliHLTTPCLog::kDec<<"Rows in slice " << fSlice << " dont match "<<lrow<<" "<<r<<ENDLOG;
467 continue;
468 }
469
470 ndigits[lrow] = 0;
471 fDigits->First();
472 do {
473 time=fDigits->CurrentRow();
474 pad=fDigits->CurrentColumn();
475 dig = fDigits->GetDigit(time,pad);
476 if(dig <= fParam->GetZeroSup()) continue;
477 if(dig >= AliHLTTPCTransform::GetADCSat())
478 dig = AliHLTTPCTransform::GetADCSat();
479
480 AliHLTTPCTransform::Raw2Local(xyz,sector,row,pad,time);
481 // if(fParam->GetPadRowRadii(sector,row)<230./250.*fabs(xyz[2]))
482 // continue; // why 230???
483
484 ndigits[lrow]++; //for this row only
485 ndigitcount++; //total number of digits to be published
486
487 } while (fDigits->Next());
488 //cout << lrow << " " << ndigits[lrow] << " - " << ndigitcount << endl;
489 }
490 nrows++;
491 }
492
493 Int_t size = sizeof(AliHLTTPCDigitData)*ndigitcount
494 + nrows*sizeof(AliHLTTPCDigitRowData);
495
496 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCFileHandler::AliDigits2Memory","Digits")
497 <<AliHLTTPCLog::kDec<<"Found "<<ndigitcount<<" Digits"<<ENDLOG;
498
499 data=(AliHLTTPCDigitRowData*) Allocate(size);
500 nrow = (UInt_t)nrows;
501 AliHLTTPCDigitRowData *tempPt = data;
502
503 for(Int_t r=fRowMin;r<=fRowMax;r++){
504 Int_t n=fIndex[fSlice][r];
505 tempPt->fRow = r;
506 tempPt->fNDigit = 0;
507
508 if(n!=-1){//data on that row
509 fDigitsTree->GetEvent(n);
510 fParam->AdjustSectorRow(fDigits->GetID(),sector,row);
511 AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row);
512 if(lrow!=r){
513 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliDigits2Memory","Row")
514 <<AliHLTTPCLog::kDec<<"Rows on slice " << fSlice << " dont match "<<lrow<<" "<<r<<ENDLOG;
515 continue;
516 }
517
518 tempPt->fNDigit = ndigits[lrow];
519
520 Int_t localcount=0;
521 fDigits->First();
522 do {
523 time=fDigits->CurrentRow();
524 pad=fDigits->CurrentColumn();
525 dig = fDigits->GetDigit(time,pad);
526 if (dig <= fParam->GetZeroSup()) continue;
527 if(dig >= AliHLTTPCTransform::GetADCSat())
528 dig = AliHLTTPCTransform::GetADCSat();
529
530 //Exclude data outside cone:
531 AliHLTTPCTransform::Raw2Local(xyz,sector,row,pad,time);
532 // if(fParam->GetPadRowRadii(sector,row)<230./250.*fabs(xyz[2]))
533 // continue; // why 230???
534
535 if(localcount >= ndigits[lrow])
536 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCFileHandler::AliDigits2Binary","Memory")
537 <<AliHLTTPCLog::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
538 <<ndigits[lrow]<<ENDLOG;
539
540 tempPt->fDigitData[localcount].fCharge=dig;
541 tempPt->fDigitData[localcount].fPad=pad;
542 tempPt->fDigitData[localcount].fTime=time;
543#ifdef do_mc
544 tempPt->fDigitData[localcount].fTrackID[0] = fDigits->GetTrackID(time,pad,0);
545 tempPt->fDigitData[localcount].fTrackID[1] = fDigits->GetTrackID(time,pad,1);
546 tempPt->fDigitData[localcount].fTrackID[2] = fDigits->GetTrackID(time,pad,2);
547#endif
548 localcount++;
549 } while (fDigits->Next());
550 }
551 Byte_t *tmp = (Byte_t*)tempPt;
552 Int_t size = sizeof(AliHLTTPCDigitRowData)
553 + ndigits[lrow]*sizeof(AliHLTTPCDigitData);
554 tmp += size;
555 tempPt = (AliHLTTPCDigitRowData*)tmp;
556 }
557 delete [] ndigits;
558 return data;
559}
560
561AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliAltroDigits2Memory(UInt_t & nrow,Int_t event,Bool_t eventmerge)
562{
563 //Read data from AliROOT file into memory, and store it in the HLT data format.
564 //Returns a pointer to the data.
565 //This functions filter out single timebins, which is noise. The timebins which
566 //are removed are timebins which have the 4 zero neighbours;
567 //(pad-1,time),(pad+1,time),(pad,time-1),(pad,time+1).
568
569 AliHLTTPCDigitRowData *data = 0;
570 nrow=0;
571
572 if(!fInAli){
573 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliAltroDigits2Memory","File")
574 <<"No Input avalible: Pointer to TFile == NULL"<<ENDLOG;
575 return 0;
576 }
a6c02c85 577 if(eventmerge == kTRUE && event >= 1024)
578 {
579 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliAltroDigits2Memory","TrackIDs")
580 <<"Too many events if you want to merge!"<<ENDLOG;
581 return 0;
582 }
583 delete fDigits;
584 fDigits=0;
a6c02c85 585 /* Dont understand why we have to do
586 reload the tree, but otherwise the code crashes */
587 fDigitsTree=0;
588 if(!GetDigitsTree(event)) return 0;
a6c02c85 589
590 UShort_t dig;
591 Int_t time,pad,sector,row;
592 Int_t nrows=0;
593 Int_t ndigitcount=0;
594 Int_t entries = (Int_t)fDigitsTree->GetEntries();
595 if(entries==0) {
596 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliAltroDigits2Memory","ndigits")
597 <<"No TPC digits (entries==0)!"<<ENDLOG;
598 nrow = (UInt_t)(fRowMax-fRowMin+1);
599 Int_t size = nrow*sizeof(AliHLTTPCDigitRowData);
600 data=(AliHLTTPCDigitRowData*) Allocate(size);
601 AliHLTTPCDigitRowData *tempPt = data;
602 for(Int_t r=fRowMin;r<=fRowMax;r++){
603 tempPt->fRow = r;
604 tempPt->fNDigit = 0;
605 tempPt++;
606 }
607 return data;
608 }
609 Int_t * ndigits = new Int_t[fRowMax+1];
610 Int_t lslice,lrow;
611 Int_t zerosupval=AliHLTTPCTransform::GetZeroSup();
612 Float_t xyz[3];
613
614 for(Int_t r=fRowMin;r<=fRowMax;r++){
615 Int_t n=fIndex[fSlice][r];
616
617 ndigits[r] = 0;
618
619 if(n!=-1){//data on that row
620 fDigitsTree->GetEvent(n);
621 fParam->AdjustSectorRow(fDigits->GetID(),sector,row);
622 AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row);
623 //cout << lslice << " " << fSlice << " " << lrow << " " << r << " " << sector << " " << row << endl;
624 if((lslice!=fSlice)||(lrow!=r)){
625 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliAltroDigits2Memory","Row")
626 <<AliHLTTPCLog::kDec<<"Rows on slice " << fSlice << " dont match "<<lrow<<" "<<r<<ENDLOG;
627 continue;
628 }
629
630 fDigits->ExpandBuffer();
631 fDigits->ExpandTrackBuffer();
632 for(Int_t i=0; i<fDigits->GetNCols(); i++){
633 for(Int_t j=0; j<fDigits->GetNRows(); j++){
634 pad=i;
635 time=j;
636 dig = fDigits->GetDigitFast(time,pad);
637 if(dig <= zerosupval) continue;
638 if(dig >= AliHLTTPCTransform::GetADCSat())
639 dig = AliHLTTPCTransform::GetADCSat();
640
641 //Check for single timebins, and remove them because they are noise for sure.
642 if(i>0 && i<fDigits->GetNCols()-1 && j>0 && j<fDigits->GetNRows()-1)
643 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
644 fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
645 fDigits->GetDigitFast(time+1,pad)<=zerosupval &&
646 fDigits->GetDigitFast(time,pad+1)<=zerosupval)
647 continue;
648
649 //Boundaries:
650 if(i==0) //pad==0
651 {
652 if(j < fDigits->GetNRows()-1 && j > 0)
653 {
654 if(fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
655 fDigits->GetDigitFast(time+1,pad)<=zerosupval &&
656 fDigits->GetDigitFast(time,pad+1)<=zerosupval)
657 continue;
658 }
659 else if(j > 0)
660 {
661 if(fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
662 fDigits->GetDigitFast(time,pad+1)<=zerosupval)
663 continue;
664 }
665 }
666 if(j==0)
667 {
668 if(i < fDigits->GetNCols()-1 && i > 0)
669 {
670 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
671 fDigits->GetDigitFast(time,pad+1)<=zerosupval &&
672 fDigits->GetDigitFast(time+1,pad)<=zerosupval)
673 continue;
674 }
675 else if(i > 0)
676 {
677 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
678 fDigits->GetDigitFast(time+1,pad)<=zerosupval)
679 continue;
680 }
681 }
682
683 if(i==fDigits->GetNCols()-1)
684 {
685 if(j>0 && j<fDigits->GetNRows()-1)
686 {
687 if(fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
688 fDigits->GetDigitFast(time+1,pad)<=zerosupval &&
689 fDigits->GetDigitFast(time,pad-1)<=zerosupval)
690 continue;
691 }
692 else if(j==0 && j<fDigits->GetNRows()-1)
693 {
694 if(fDigits->GetDigitFast(time+1,pad)<=zerosupval &&
695 fDigits->GetDigitFast(time,pad-1)<=zerosupval)
696 continue;
697 }
698 else
699 {
700 if(fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
701 fDigits->GetDigitFast(time,pad-1)<=zerosupval)
702 continue;
703 }
704 }
705
706 if(j==fDigits->GetNRows()-1)
707 {
708 if(i>0 && i<fDigits->GetNCols()-1)
709 {
710 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
711 fDigits->GetDigitFast(time,pad+1)<=zerosupval &&
712 fDigits->GetDigitFast(time-1,pad)<=zerosupval)
713 continue;
714 }
715 else if(i==0 && fDigits->GetNCols()-1)
716 {
717 if(fDigits->GetDigitFast(time,pad+1)<=zerosupval &&
718 fDigits->GetDigitFast(time-1,pad)<=zerosupval)
719 continue;
720 }
721 else
722 {
723 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
724 fDigits->GetDigitFast(time-1,pad)<=zerosupval)
725 continue;
726 }
727 }
728
729 AliHLTTPCTransform::Raw2Local(xyz,sector,row,pad,time);
730 // if(fParam->GetPadRowRadii(sector,row)<230./250.*fabs(xyz[2]))
731 // continue;
732
733 ndigits[lrow]++; //for this row only
734 ndigitcount++; //total number of digits to be published
735 }
736 }
737 }
738 nrows++;
739 }
740
741 Int_t size = sizeof(AliHLTTPCDigitData)*ndigitcount
742 + nrows*sizeof(AliHLTTPCDigitRowData);
743
744 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCFileHandler::AliAltroDigits2Memory","Digits")
745 <<AliHLTTPCLog::kDec<<"Found "<<ndigitcount<<" Digits"<<ENDLOG;
746
747 data=(AliHLTTPCDigitRowData*) Allocate(size);
748 nrow = (UInt_t)nrows;
749 AliHLTTPCDigitRowData *tempPt = data;
750
751 for(Int_t r=fRowMin;r<=fRowMax;r++){
752 Int_t n=fIndex[fSlice][r];
753 tempPt->fRow = r;
754 tempPt->fNDigit = 0;
755 if(n!=-1){ //no data on that row
756 fDigitsTree->GetEvent(n);
757 fParam->AdjustSectorRow(fDigits->GetID(),sector,row);
758 AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row);
759
760 if(lrow!=r){
761 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliAltroDigits2Memory","Row")
762 <<AliHLTTPCLog::kDec<<"Rows on slice " << fSlice << " dont match "<<lrow<<" "<<r<<ENDLOG;
763 continue;
764 }
765
766 tempPt->fNDigit = ndigits[lrow];
767
768 Int_t localcount=0;
769 fDigits->ExpandBuffer();
770 fDigits->ExpandTrackBuffer();
771 for(Int_t i=0; i<fDigits->GetNCols(); i++){
772 for(Int_t j=0; j<fDigits->GetNRows(); j++){
773 pad=i;
774 time=j;
775 dig = fDigits->GetDigitFast(time,pad);
776 if(dig <= zerosupval) continue;
777 if(dig >= AliHLTTPCTransform::GetADCSat())
778 dig = AliHLTTPCTransform::GetADCSat();
779
780 //Check for single timebins, and remove them because they are noise for sure.
781 if(i>0 && i<fDigits->GetNCols()-1 && j>0 && j<fDigits->GetNRows()-1)
782 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
783 fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
784 fDigits->GetDigitFast(time+1,pad)<=zerosupval &&
785 fDigits->GetDigitFast(time,pad+1)<=zerosupval)
786 continue;
787
788 //Boundaries:
789 if(i==0) //pad ==0
790 {
791 if(j < fDigits->GetNRows()-1 && j > 0)
792 {
793 if(fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
794 fDigits->GetDigitFast(time+1,pad)<=zerosupval &&
795 fDigits->GetDigitFast(time,pad+1)<=zerosupval)
796 continue;
797 }
798 else if(j > 0)
799 {
800 if(fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
801 fDigits->GetDigitFast(time,pad+1)<=zerosupval)
802 continue;
803 }
804 }
805 if(j==0)
806 {
807 if(i < fDigits->GetNCols()-1 && i > 0)
808 {
809 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
810 fDigits->GetDigitFast(time,pad+1)<=zerosupval &&
811 fDigits->GetDigitFast(time+1,pad)<=zerosupval)
812 continue;
813 }
814 else if(i > 0)
815 {
816 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
817 fDigits->GetDigitFast(time+1,pad)<=zerosupval)
818 continue;
819 }
820 }
821
822 if(i == fDigits->GetNCols()-1)
823 {
824 if(j>0 && j<fDigits->GetNRows()-1)
825 {
826 if(fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
827 fDigits->GetDigitFast(time+1,pad)<=zerosupval &&
828 fDigits->GetDigitFast(time,pad-1)<=zerosupval)
829 continue;
830 }
831 else if(j==0 && j<fDigits->GetNRows()-1)
832 {
833 if(fDigits->GetDigitFast(time+1,pad)<=zerosupval &&
834 fDigits->GetDigitFast(time,pad-1)<=zerosupval)
835 continue;
836 }
837 else
838 {
839 if(fDigits->GetDigitFast(time-1,pad)<=zerosupval &&
840 fDigits->GetDigitFast(time,pad-1)<=zerosupval)
841 continue;
842 }
843 }
844 if(j==fDigits->GetNRows()-1)
845 {
846 if(i>0 && i<fDigits->GetNCols()-1)
847 {
848 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
849 fDigits->GetDigitFast(time,pad+1)<=zerosupval &&
850 fDigits->GetDigitFast(time-1,pad)<=zerosupval)
851 continue;
852 }
853 else if(i==0 && fDigits->GetNCols()-1)
854 {
855 if(fDigits->GetDigitFast(time,pad+1)<=zerosupval &&
856 fDigits->GetDigitFast(time-1,pad)<=zerosupval)
857 continue;
858 }
859 else
860 {
861 if(fDigits->GetDigitFast(time,pad-1)<=zerosupval &&
862 fDigits->GetDigitFast(time-1,pad)<=zerosupval)
863 continue;
864 }
865 }
866
867 AliHLTTPCTransform::Raw2Local(xyz,sector,row,pad,time);
868 // if(fParam->GetPadRowRadii(sector,row)<230./250.*fabs(xyz[2]))
869 // continue;
870
871 if(localcount >= ndigits[lrow])
872 LOG(AliHLTTPCLog::kFatal,"AliHLTTPCFileHandler::AliAltroDigits2Binary","Memory")
873 <<AliHLTTPCLog::kDec<<"Mismatch: localcount "<<localcount<<" ndigits "
874 <<ndigits[lrow]<<ENDLOG;
875
876 tempPt->fDigitData[localcount].fCharge=dig;
877 tempPt->fDigitData[localcount].fPad=pad;
878 tempPt->fDigitData[localcount].fTime=time;
879#ifdef do_mc
880 tempPt->fDigitData[localcount].fTrackID[0] = (fDigits->GetTrackIDFast(time,pad,0)-2);
881 tempPt->fDigitData[localcount].fTrackID[1] = (fDigits->GetTrackIDFast(time,pad,1)-2);
882 tempPt->fDigitData[localcount].fTrackID[2] = (fDigits->GetTrackIDFast(time,pad,2)-2);
883 if(eventmerge == kTRUE) //careful track mc info will be touched
884 {//Event are going to be merged, so event number is stored in the upper 10 bits.
885 tempPt->fDigitData[localcount].fTrackID[0] += 128; //leave some room
886 tempPt->fDigitData[localcount].fTrackID[1] += 128; //for neg. numbers
887 tempPt->fDigitData[localcount].fTrackID[2] += 128;
888 tempPt->fDigitData[localcount].fTrackID[0] += ((event&0x3ff)<<22);
889 tempPt->fDigitData[localcount].fTrackID[1] += ((event&0x3ff)<<22);
890 tempPt->fDigitData[localcount].fTrackID[2] += ((event&0x3ff)<<22);
891 }
892#endif
893 localcount++;
894 }
895 }
896 }
897 Byte_t *tmp = (Byte_t*)tempPt;
898 Int_t size = sizeof(AliHLTTPCDigitRowData)
899 + ndigits[r]*sizeof(AliHLTTPCDigitData);
900 tmp += size;
901 tempPt = (AliHLTTPCDigitRowData*)tmp;
902 }
903 delete [] ndigits;
904 return data;
905}
906
907Bool_t AliHLTTPCFileHandler::GetDigitsTree(Int_t event)
908{
909 //Connects to the TPC digit tree in the AliROOT file.
a6c02c85 910 AliLoader* tpcLoader = fInAli->GetLoader("TPCLoader");
911 if(!tpcLoader){
912 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::GetDigitsTree","File")
913 <<"Pointer to AliLoader for TPC = 0x0 "<<ENDLOG;
914 return kFALSE;
915 }
916 fInAli->GetEvent(event);
917 tpcLoader->LoadDigits();
918 fDigitsTree = tpcLoader->TreeD();
a6c02c85 919 if(!fDigitsTree)
920 {
921 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::GetDigitsTree","Digits Tree")
922 <<AliHLTTPCLog::kHex<<"Error getting digitstree "<<(void*)fDigitsTree<<ENDLOG;
923 return kFALSE;
924 }
925 fDigitsTree->GetBranch("Segment")->SetAddress(&fDigits);
926
927 if(!fIndexCreated) return CreateIndex();
928 else return kTRUE;
929}
930
95d48915 931void AliHLTTPCFileHandler::AliDigits2RootFile(AliHLTTPCDigitRowData *rowPt,Char_t *newDigitsfile)
a6c02c85 932{
933 //Write the data stored in rowPt, into a new AliROOT file.
934 //The data is stored in the AliROOT format
935 //This is specially a nice thing if you have modified data, and wants to run it
936 //through the offline reconstruction chain.
937 //The arguments is a pointer to the data, and the name of the new AliROOT file.
938 //Remember to pass the original AliROOT file (the one that contains the original
939 //simulated data) to this object, in order to retrieve the MC id's of the digits.
940
941 if(!fInAli)
942 {
943 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliDigits2RootFile","File")
944 <<"No rootfile "<<ENDLOG;
945 return;
946 }
947 if(!fParam)
948 {
949 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliDigits2RootFile","File")
950 <<"No parameter object. Run on rootfile "<<ENDLOG;
951 return;
952 }
953
a6c02c85 954 //Get the original digitstree:
955 AliLoader* tpcLoader = fInAli->GetLoader("TPCLoader");
956 if(!tpcLoader){
957 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliDigits2RootFile","File")
958 <<"Pointer to AliLoader for TPC = 0x0 "<<ENDLOG;
959 return;
960 }
961 tpcLoader->LoadDigits();
962 TTree *t=tpcLoader->TreeD();
963
95d48915 964 AliTPCDigitsArray *oldArray = new AliTPCDigitsArray();
965 oldArray->Setup(fParam);
966 oldArray->SetClass("AliSimDigits");
a6c02c85 967
95d48915 968 Bool_t ok = oldArray->ConnectTree(t);
a6c02c85 969 if(!ok)
970 {
971 LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliDigits2RootFile","File")
972 << "No digits tree object" << ENDLOG;
973 return;
974 }
975
95d48915 976 tpcLoader->SetDigitsFileName(newDigitsfile);
a6c02c85 977 tpcLoader->MakeDigitsContainer();
978
979 //setup a new one, or connect it to the existing one:
980 AliTPCDigitsArray *arr = new AliTPCDigitsArray();
981 arr->SetClass("AliSimDigits");
982 arr->Setup(fParam);
983 arr->MakeTree(tpcLoader->TreeD());
a6c02c85 984
985 Int_t digcounter=0,trackID[3];
986
987 for(Int_t i=fRowMin; i<=fRowMax; i++)
988 {
989
990 if((Int_t)rowPt->fRow != i)
991 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliDigits2RootFile","Data")
992 <<"Mismatching row numbering "<<(Int_t)rowPt->fRow<<" "<<i<<ENDLOG;
993
994 Int_t sector,row;
995 AliHLTTPCTransform::Slice2Sector(fSlice,i,sector,row);
996
95d48915 997 AliSimDigits *oldDig = (AliSimDigits*)oldArray->LoadRow(sector,row);
a6c02c85 998 AliSimDigits * dig = (AliSimDigits*)arr->CreateRow(sector,row);
95d48915 999 oldDig->ExpandBuffer();
1000 oldDig->ExpandTrackBuffer();
a6c02c85 1001 dig->ExpandBuffer();
1002 dig->ExpandTrackBuffer();
1003
95d48915 1004 if(!oldDig)
a6c02c85 1005 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliDigits2RootFile","Data")
1006 <<"No padrow " << sector << " " << row <<ENDLOG;
1007
1008 AliHLTTPCDigitData *digPt = rowPt->fDigitData;
1009 digcounter=0;
1010 for(UInt_t j=0; j<rowPt->fNDigit; j++)
1011 {
1012 Short_t charge = (Short_t)digPt[j].fCharge;
1013 Int_t pad = (Int_t)digPt[j].fPad;
1014 Int_t time = (Int_t)digPt[j].fTime;
1015
1016 if(charge == 0) //Only write the digits that has not been removed
1017 {
1018 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliDigits2RootFile","Data")
1019 <<"Zero charge" <<ENDLOG;
1020 continue;
1021 }
1022
1023 digcounter++;
1024
1025 //Tricks to get and set the correct track id's.
1026 for(Int_t t=0; t<3; t++)
1027 {
95d48915 1028 Int_t label = oldDig->GetTrackIDFast(time,pad,t);
a6c02c85 1029 if(label > 1)
1030 trackID[t] = label - 2;
1031 else if(label==0)
1032 trackID[t] = -2;
1033 else
1034 trackID[t] = -1;
1035 }
1036
1037 dig->SetDigitFast(charge,time,pad);
1038
1039 for(Int_t t=0; t<3; t++)
1040 ((AliSimDigits*)dig)->SetTrackIDFast(trackID[t],time,pad,t);
1041
1042 }
1043 //cout<<"Wrote "<<digcounter<<" on row "<<i<<endl;
1044 UpdateRowPointer(rowPt);
1045 arr->StoreRow(sector,row);
1046 arr->ClearRow(sector,row);
95d48915 1047 oldArray->ClearRow(sector,row);
a6c02c85 1048 }
1049
1050 char treeName[100];
1051 sprintf(treeName,"TreeD_%s_0",fParam->GetTitle());
1052
a6c02c85 1053 arr->GetTree()->SetName(treeName);
1054 arr->GetTree()->AutoSave();
1055 tpcLoader->WriteDigits("OVERWRITE");
a6c02c85 1056 delete arr;
95d48915 1057 delete oldArray;
a6c02c85 1058}
1059
1060///////////////////////////////////////// Point IO
1061Bool_t AliHLTTPCFileHandler::AliPoints2Binary(Int_t eventn)
1062{
1063 //points to binary
1064 Bool_t out = kTRUE;
1065 UInt_t npoint;
1066 AliHLTTPCSpacePointData *data = AliPoints2Memory(npoint,eventn);
1067 out = Memory2Binary(npoint,data);
1068 Free();
1069 return out;
1070}
1071
1072AliHLTTPCSpacePointData * AliHLTTPCFileHandler::AliPoints2Memory(UInt_t & npoint,Int_t eventn)
1073{
1074 //points to memory
1075 AliHLTTPCSpacePointData *data = 0;
1076 npoint=0;
1077 if(!fInAli){
1078 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliPoints2Memory","File")
1079 <<"No Input avalible: no object fInAli"<<ENDLOG;
1080 return 0;
1081 }
a6c02c85 1082
1083 TDirectory *savedir = gDirectory;
a6c02c85 1084 AliLoader* tpcLoader = fInAli->GetLoader("TPCLoader");
1085 if(!tpcLoader){
1086 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::AliPoints2Memory","File")
1087 <<"Pointer to AliLoader for TPC = 0x0 "<<ENDLOG;
1088 return 0;
1089 }
1090 fInAli->GetEvent(eventn);
1091 tpcLoader->LoadRecPoints();
1092
1093 AliTPCClustersArray carray;
1094 carray.Setup(fParam);
1095 carray.SetClusterType("AliTPCcluster");
1096 Bool_t clusterok = carray.ConnectTree(tpcLoader->TreeR());
a6c02c85 1097
1098 if(!clusterok) return 0;
1099
1100 AliTPCClustersRow ** clusterrow =
1101 new AliTPCClustersRow*[ (int)carray.GetTree()->GetEntries()];
1102 Int_t *rows = new int[ (int)carray.GetTree()->GetEntries()];
1103 Int_t *sects = new int[ (int)carray.GetTree()->GetEntries()];
1104 Int_t sum=0;
1105
1106 Int_t lslice,lrow;
1107 for(Int_t i=0; i<carray.GetTree()->GetEntries(); i++){
1108 AliSegmentID *s = carray.LoadEntry(i);
1109 Int_t sector,row;
1110 fParam->AdjustSectorRow(s->GetID(),sector,row);
1111 rows[i] = row;
1112 sects[i] = sector;
1113 clusterrow[i] = 0;
1114 AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row);
1115 if(fSlice != lslice || lrow<fRowMin || lrow>fRowMax) continue;
1116 clusterrow[i] = carray.GetRow(sector,row);
1117 if(clusterrow[i])
1118 sum+=clusterrow[i]->GetArray()->GetEntriesFast();
1119 }
1120 UInt_t size = sum*sizeof(AliHLTTPCSpacePointData);
1121
1122 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCFileHandler::AliPoints2Memory","File")
1123 <<AliHLTTPCLog::kDec<<"Found "<<sum<<" SpacePoints"<<ENDLOG;
1124
1125 data = (AliHLTTPCSpacePointData *) Allocate(size);
1126 npoint = sum;
1127 UInt_t n=0;
1128 Int_t pat=fPatch;
1129 if(fPatch==-1)
1130 pat=0;
1131 for(Int_t i=0; i<carray.GetTree()->GetEntries(); i++){
1132 if(!clusterrow[i]) continue;
1133 Int_t row = rows[i];
1134 Int_t sector = sects[i];
1135 AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row);
95d48915 1136 Int_t entriesInRow = clusterrow[i]->GetArray()->GetEntriesFast();
1137 for(Int_t j = 0;j<entriesInRow;j++){
a6c02c85 1138 AliTPCcluster *c = (AliTPCcluster*)(*clusterrow[i])[j];
1139 data[n].fZ = c->GetZ();
1140 data[n].fY = c->GetY();
1141 data[n].fX = fParam->GetPadRowRadii(sector,row);
1142 data[n].fCharge = (UInt_t)c->GetQ();
1143 data[n].fID = n+((fSlice&0x7f)<<25)+((pat&0x7)<<22);//uli
1144 data[n].fPadRow = lrow;
1145 data[n].fSigmaY2 = c->GetSigmaY2();
1146 data[n].fSigmaZ2 = c->GetSigmaZ2();
1147#ifdef do_mc
1148 data[n].fTrackID[0] = c->GetLabel(0);
1149 data[n].fTrackID[1] = c->GetLabel(1);
1150 data[n].fTrackID[2] = c->GetLabel(2);
1151#endif
1152 if(fMC) fprintf(fMC,"%d %d\n",data[n].fID,c->GetLabel(0));
1153 n++;
1154 }
1155 }
1156 for(Int_t i=0;i<carray.GetTree()->GetEntries();i++){
1157 Int_t row = rows[i];
1158 Int_t sector = sects[i];
1159 if(carray.GetRow(sector,row))
1160 carray.ClearRow(sector,row);
1161 }
1162
1163 delete [] clusterrow;
1164 delete [] rows;
1165 delete [] sects;
1166 savedir->cd();
1167
1168 return data;
1169}
1170