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