]> git.uio.no Git - u/mrichter/AliRoot.git/blame - HLT/TPCLib/AliHLTTPCFileHandler.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
removing old CF configurations, ids redirected to HWCF; global tracking option enable...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCFileHandler.cxx
CommitLineData
8d637fa1 1// $Id$
4aa41877 2// Original: AliHLTFileHandler.cxx,v 1.49 2005/06/23 17:46:55 hristov
a6c02c85 3
8d637fa1 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
5578cf60 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
8d637fa1 33
055fed30 34#include <cassert>
a6c02c85 35#include <TClonesArray.h>
36#include <TSystem.h>
37#include <TMath.h>
38
c93255fe 39#include "AliLoader.h"
a6c02c85 40#include <AliRunLoader.h>
95d48915 41#include <TObject.h>
42#include <TFile.h>
43#include <TTree.h>
a6c02c85 44#include <AliTPCParamSR.h>
45#include <AliTPCDigitsArray.h>
46#include <AliTPCClustersArray.h>
47#include <AliTPCcluster.h>
48#include <AliTPCClustersRow.h>
49#include <AliSimDigits.h>
286c9940 50#include "AliCDBManager.h"
51#include "AliCDBEntry.h"
a6c02c85 52
53#include "AliHLTTPCLogging.h"
54#include "AliHLTTPCTransform.h"
a6c02c85 55#include "AliHLTTPCDigitData.h"
95d48915 56//#include "AliHLTTPCTrackSegmentData.h"
a6c02c85 57#include "AliHLTTPCSpacePointData.h"
95d48915 58//#include "AliHLTTPCTrackArray.h"
a6c02c85 59#include "AliHLTTPCFileHandler.h"
c5123824 60#include "AliHLTTPCMapping.h"
61#include "AliHLTAltroEncoder.h"
a6c02c85 62
63#if __GNUC__ >= 3
64using namespace std;
65#endif
66
86268ca8 67/**
a6c02c85 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
105ClassImp(AliHLTTPCFileHandler)
106
600e6a1b 107AliHLTTPCFileHandler::AliHLTTPCFileHandler(Bool_t b)
108 :
109 fInAli(NULL),
600e6a1b 110 fUseRunLoader(kFALSE),
600e6a1b 111 fParam(NULL),
600e6a1b 112 fDigits(NULL),
113 fDigitsTree(NULL),
2a083ac4 114 fMC(NULL),
600e6a1b 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
600e6a1b 127AliHLTTPCFileHandler::~AliHLTTPCFileHandler()
128{
129 //Destructor
130 if(fMC) CloseMCOutput();
131 FreeDigitsTree();
132 if(fInAli) CloseAliInput();
133}
134
a6c02c85 135// of course on start up the index is not created
136Bool_t AliHLTTPCFileHandler::fgStaticIndexCreated=kFALSE;
137Int_t AliHLTTPCFileHandler::fgStaticIndex[36][159];
138
139void 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
150Int_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
271cc5e0 155 const int fnamelen=1024;
156 Char_t fname[fnamelen];
a6c02c85 157 if(prefix)
271cc5e0 158 snprintf(fname,fnamelen, "%s-%d.txt",prefix,event);
a6c02c85 159 else
271cc5e0 160 snprintf(fname,fnamelen, "TPC.Digits.staticindex-%d.txt",event);
a6c02c85 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
174Int_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
271cc5e0 183 const int fnamelen=1024;
184 Char_t fname[fnamelen];
a6c02c85 185 if(prefix)
271cc5e0 186 snprintf(fname,fnamelen,"%s-%d.txt",prefix,event);
a6c02c85 187 else
271cc5e0 188 snprintf(fname,fnamelen,"TPC.Digits.staticindex-%d.txt",event);
a6c02c85 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
a6c02c85 203void AliHLTTPCFileHandler::FreeDigitsTree()
204{
205 //free digits tree
61692dfa 206 if (fDigits) {
207 delete fDigits;
208 }
a6c02c85 209 fDigits=0;
a6c02c85 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
219Bool_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
231Bool_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
243void 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
255Bool_t AliHLTTPCFileHandler::SetAliInput()
256{
257 //set ali input
286c9940 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
a6c02c85 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 }
286c9940 282 }
a6c02c85 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 }
a6c02c85 288
289 return kTRUE;
290}
291
292Bool_t AliHLTTPCFileHandler::SetAliInput(Char_t *name)
293{
294 //Open the AliROOT file with name.
a6c02c85 295 fInAli= AliRunLoader::Open(name);
a6c02c85 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
a6c02c85 304Bool_t AliHLTTPCFileHandler::SetAliInput(AliRunLoader *runLoader)
305{
306 //set ali input as runloader
cae431d0 307 if(!runLoader){
a6c02c85 308 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::SetAliInput","File Open")
cae431d0 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;
a6c02c85 315 return kFALSE;
316 }
cae431d0 317 fInAli=runLoader;
318 fUseRunLoader = kTRUE;
a6c02c85 319 return SetAliInput();
320}
a6c02c85 321
322void AliHLTTPCFileHandler::CloseAliInput()
323{
324 //close ali input
a6c02c85 325 if(fUseRunLoader) return;
a6c02c85 326 if(!fInAli){
327 LOG(AliHLTTPCLog::kWarning,"AliHLTTPCFileHandler::CloseAliInput","RunLoader")
328 <<"Nothing to Close"<<ENDLOG;
329 return;
330 }
a6c02c85 331
332 delete fInAli;
333 fInAli = 0;
334}
335
336Bool_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 }
a6c02c85 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();
a6c02c85 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
5578cf60 368Bool_t AliHLTTPCFileHandler::AliDigits2BinaryFile(Int_t event,Bool_t altro)
a6c02c85 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);
5578cf60 378 out = Memory2BinaryFile(nrow,data);
a6c02c85 379 Free();
380 return out;
381}
382
383Bool_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
400Bool_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
5d2abf3b 409 //Int_t lslice,lrow;
a6c02c85 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 }
0ba35c53 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);
a6c02c85 426 if(fIndex[lslice][lrow]==-1) {
427 fIndex[lslice][lrow]=n;
428 }
429 }
0ba35c53 430 assert(AliHLTTPCTransform::GetNSlice()==fgkNSlice);
431 assert(AliHLTTPCTransform::GetNRows()==fgkNRow);
a6c02c85 432 if(fUseStaticIndex) { // create static index
0ba35c53 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];
a6c02c85 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
0ba35c53 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];
a6c02c85 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
5578cf60 456AliHLTTPCDigitRowData * AliHLTTPCFileHandler::AliDigits2Memory(UInt_t & nrow,Int_t event, Byte_t* tgtBuffer, UInt_t *pTgtSize)
a6c02c85 457{
5578cf60 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.
a6c02c85 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
a6c02c85 471 if(!fDigitsTree)
472 if(!GetDigitsTree(event)) return 0;
473
474 UShort_t dig;
475 Int_t time,pad,sector,row;
a6c02c85 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);
298ef463 483 UInt_t size = nrow*sizeof(AliHLTTPCDigitRowData);
5578cf60 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 }
a6c02c85 492 AliHLTTPCDigitRowData *tempPt = data;
5578cf60 493 if (data) {
494 if (pTgtSize) *pTgtSize=size;
a6c02c85 495 for(Int_t r=fRowMin;r<=fRowMax;r++){
496 tempPt->fRow = r;
497 tempPt->fNDigit = 0;
498 tempPt++;
499 }
5578cf60 500 }
a6c02c85 501 return data;
502 }
503
504 Int_t * ndigits = new Int_t[fRowMax+1];
8d637fa1 505 memset(ndigits, 0, (fRowMax+1)*sizeof(Int_t));
a6c02c85 506 Float_t xyz[3];
507
5578cf60 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
0ba35c53 514 assert(fRowMax<fgkNRow);
515 for(Int_t r=fRowMin;r<=fRowMax && r<fgkNRow;r++){
a6c02c85 516 Int_t n=fIndex[fSlice][r];
5578cf60 517 if(n!=-1){ // there is data on that row available
055fed30 518 Int_t lslice,lrow;
a6c02c85 519 fDigitsTree->GetEvent(n);
520 fParam->AdjustSectorRow(fDigits->GetID(),sector,row);
521 AliHLTTPCTransform::Sector2Slice(lslice,lrow,sector,row);
055fed30 522// LOG(AliHLTTPCLog::kInformational,"AliHLTTPCFileHandler::AliDigits2Memory","Digits")
523// << "Sector "<<sector<<" Row " << row << " Slice " << lslice << " lrow " << lrow<<ENDLOG;
a6c02c85 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;
2f7aeadf 532 for (bool bHaveData=fDigits->First();
533 bHaveData;
534 bHaveData=fDigits->Next()) {
a6c02c85 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();
2f7aeadf 541
542 // if we switch to AliTPCTransform, this maybe needs to be
543 // adjusted as well
a6c02c85 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
2f7aeadf 551 }
a6c02c85 552 //cout << lrow << " " << ndigits[lrow] << " - " << ndigitcount << endl;
553 }
055fed30 554 //see comment below//nrows++;
a6c02c85 555 }
055fed30 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
a6c02c85 566 + nrows*sizeof(AliHLTTPCDigitRowData);
567
568 LOG(AliHLTTPCLog::kDebug,"AliHLTTPCFileHandler::AliDigits2Memory","Digits")
055fed30 569 << "Found "<<ndigitcount<<" Digits in " << nrows << " rows out of [" << fRowMin << "," << fRowMax <<"]"<<ENDLOG;
570
5578cf60 571 if (tgtBuffer!=NULL && pTgtSize!=NULL && *pTgtSize>0) {
055fed30 572 if (bufferSize<=*pTgtSize) {
5578cf60 573 data=reinterpret_cast<AliHLTTPCDigitRowData*>(tgtBuffer);
574 } else {
575 }
055fed30 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;
5578cf60 583 }
a6c02c85 584 nrow = (UInt_t)nrows;
585 AliHLTTPCDigitRowData *tempPt = data;
055fed30 586 memset(data, 0, bufferSize);
a6c02c85 587
0ba35c53 588 for(Int_t r=fRowMin;r<=fRowMax && r<fgkNRow;r++){
a6c02c85 589 Int_t n=fIndex[fSlice][r];
055fed30 590
591 AliHLTTPCTransform::Slice2Sector(fSlice,r,sector,row);
592 tempPt->fRow = row;
a6c02c85 593 tempPt->fNDigit = 0;
594
595 if(n!=-1){//data on that row
055fed30 596 Int_t lslice,lrow;
a6c02c85 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
055fed30 606 // set the correct row no and digit count
607 tempPt->fRow = row;
a6c02c85 608 tempPt->fNDigit = ndigits[lrow];
609
610 Int_t localcount=0;
2f7aeadf 611 for (bool bHaveData=fDigits->First();
612 bHaveData;
613 bHaveData=fDigits->Next()) {
a6c02c85 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;
a6c02c85 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);
a6c02c85 637 localcount++;
2f7aeadf 638 }
a6c02c85 639 }
055fed30 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;
a6c02c85 646 }
055fed30 647 assert((Byte_t*)tempPt==((Byte_t*)data)+bufferSize);
a6c02c85 648 delete [] ndigits;
649 return data;
650}
651
c5123824 652int 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
a6c02c85 734AliHLTTPCDigitRowData * 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 }
a6c02c85 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;
a6c02c85 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;
a6c02c85 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
0ba35c53 787 for(Int_t r=fRowMin;r<=fRowMax && r<fgkNRow;r++){
a6c02c85 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;
a6c02c85 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 }
a6c02c85 1064 localcount++;
1065 }
1066 }
1067 }
1068 Byte_t *tmp = (Byte_t*)tempPt;
f7561f8d 1069 tmp += sizeof(AliHLTTPCDigitRowData)
a6c02c85 1070 + ndigits[r]*sizeof(AliHLTTPCDigitData);
a6c02c85 1071 tempPt = (AliHLTTPCDigitRowData*)tmp;
1072 }
1073 delete [] ndigits;
1074 return data;
1075}
1076
1077Bool_t AliHLTTPCFileHandler::GetDigitsTree(Int_t event)
1078{
1079 //Connects to the TPC digit tree in the AliROOT file.
a6c02c85 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();
a6c02c85 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
a6c02c85 1101///////////////////////////////////////// Point IO
1102Bool_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
1113AliHLTTPCSpacePointData * 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 }
a6c02c85 1123
1124 TDirectory *savedir = gDirectory;
a6c02c85 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());
a6c02c85 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);
95d48915 1177 Int_t entriesInRow = clusterrow[i]->GetArray()->GetEntriesFast();
1178 for(Int_t j = 0;j<entriesInRow;j++){
a6c02c85 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();
a371a266 1184 data[n].SetID( fSlice, pat, n );
a6c02c85 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