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