- use_newio switch removed from libAliHLTTPC, always on; not removed in
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCFileHandler.cxx
1 // @(#) $Id$
2 // Original: AliHLTFileHandler.cxx,v 1.49 2005/06/23 17:46:55 hristov 
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
7 #include <TClonesArray.h>
8 #include <TSystem.h>
9 #include <TMath.h>
10
11 #include <AliRunLoader.h>
12 #include <TObject.h>
13 #include <TFile.h>
14 #include <TTree.h>
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"
24 #include "AliHLTTPCDigitData.h"
25 //#include "AliHLTTPCTrackSegmentData.h"
26 #include "AliHLTTPCSpacePointData.h"
27 //#include "AliHLTTPCTrackArray.h"
28 #include "AliHLTTPCFileHandler.h"
29
30 #if __GNUC__ >= 3
31 using 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
72 ClassImp(AliHLTTPCFileHandler)
73
74 AliHLTTPCFileHandler::AliHLTTPCFileHandler(Bool_t b)
75   :
76   fInAli(NULL),
77   fUseRunLoader(kFALSE),
78   fParam(NULL),
79   fMC(NULL),
80   fDigits(NULL),
81   fDigitsTree(NULL),
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
94 AliHLTTPCFileHandler::AliHLTTPCFileHandler(const AliHLTTPCFileHandler& ref)
95   :
96   fInAli(NULL),
97   fUseRunLoader(kFALSE),
98   fParam(NULL),
99   fMC(NULL),
100   fDigits(NULL),
101   fDigitsTree(NULL),
102   fIndexCreated(kFALSE),
103   fUseStaticIndex(ref.fUseStaticIndex)
104 {
105   HLTFatal("copy constructor untested");
106 }
107
108 AliHLTTPCFileHandler& AliHLTTPCFileHandler::operator=(const AliHLTTPCFileHandler&)
109
110   HLTFatal("assignment operator untested");
111   return *this;
112 }
113
114 AliHLTTPCFileHandler::~AliHLTTPCFileHandler()
115 {
116   //Destructor
117   if(fMC) CloseMCOutput();
118   FreeDigitsTree();
119   if(fInAli) CloseAliInput();
120 }
121
122 // of course on start up the index is not created
123 Bool_t AliHLTTPCFileHandler::fgStaticIndexCreated=kFALSE;
124 Int_t  AliHLTTPCFileHandler::fgStaticIndex[36][159]; 
125
126 void 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
137 Int_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
160 Int_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
188 void 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;
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
208 Bool_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
220 Bool_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
232 void 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
244 Bool_t AliHLTTPCFileHandler::SetAliInput()
245
246   //set ali input
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   }
261
262   return kTRUE;
263 }
264
265 Bool_t AliHLTTPCFileHandler::SetAliInput(Char_t *name)
266
267   //Open the AliROOT file with name.
268   fInAli= AliRunLoader::Open(name);
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
277 Bool_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 }
289
290 void AliHLTTPCFileHandler::CloseAliInput()
291
292   //close ali input
293   if(fUseRunLoader) return;
294   if(!fInAli){
295     LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::CloseAliInput","RunLoader")
296       <<"Nothing to Close"<<ENDLOG;
297     return;
298   }
299
300   delete fInAli;
301   fInAli = 0;
302 }
303
304 Bool_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   }
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();
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  
336 Bool_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
351 Bool_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
368 Bool_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
416 AliHLTTPCDigitRowData * 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
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
561 AliHLTTPCDigitRowData * 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   }
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;
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;
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  
907 Bool_t AliHLTTPCFileHandler::GetDigitsTree(Int_t event)
908 {
909   //Connects to the TPC digit tree in the AliROOT file.
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();
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
931 void AliHLTTPCFileHandler::AliDigits2RootFile(AliHLTTPCDigitRowData *rowPt,Char_t *newDigitsfile)
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
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
964   AliTPCDigitsArray *oldArray = new AliTPCDigitsArray();
965   oldArray->Setup(fParam);
966   oldArray->SetClass("AliSimDigits");
967
968   Bool_t ok = oldArray->ConnectTree(t);
969   if(!ok)
970     {
971       LOG(AliHLTTPCLog::kError,"AliHLTTPCFileHandler::AliDigits2RootFile","File")
972         << "No digits tree object" << ENDLOG;
973       return;
974     }
975
976   tpcLoader->SetDigitsFileName(newDigitsfile);
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());
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       
997       AliSimDigits *oldDig = (AliSimDigits*)oldArray->LoadRow(sector,row);
998       AliSimDigits * dig = (AliSimDigits*)arr->CreateRow(sector,row);
999       oldDig->ExpandBuffer();
1000       oldDig->ExpandTrackBuffer();
1001       dig->ExpandBuffer();
1002       dig->ExpandTrackBuffer();
1003       
1004       if(!oldDig)
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             {
1028               Int_t label = oldDig->GetTrackIDFast(time,pad,t);
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);  
1047       oldArray->ClearRow(sector,row);
1048     }
1049
1050   char treeName[100];
1051   sprintf(treeName,"TreeD_%s_0",fParam->GetTitle());
1052   
1053   arr->GetTree()->SetName(treeName);
1054   arr->GetTree()->AutoSave();
1055   tpcLoader->WriteDigits("OVERWRITE");
1056   delete arr;
1057   delete oldArray;
1058 }
1059
1060 ///////////////////////////////////////// Point IO  
1061 Bool_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
1072 AliHLTTPCSpacePointData * 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   }
1082
1083   TDirectory *savedir = gDirectory;
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());
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);
1136     Int_t entriesInRow = clusterrow[i]->GetArray()->GetEntriesFast();
1137     for(Int_t j = 0;j<entriesInRow;j++){
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