]>
Commit | Line | Data |
---|---|---|
44875afe | 1 | // $Id$ |
a6c02c85 | 2 | |
297174de | 3 | //************************************************************************** |
4 | //* This file is property of and copyright by the ALICE HLT Project * | |
5 | //* ALICE Experiment at CERN, All rights reserved. * | |
6 | //* * | |
7 | //* Primary Authors: U. Frankenfeld, A. Vestbo, C. Loizides * | |
8 | //* Matthias Richter <Matthias.Richter@ift.uib.no> * | |
9 | //* for The ALICE HLT Project. * | |
10 | //* * | |
11 | //* Permission to use, copy, modify and distribute this software and its * | |
12 | //* documentation strictly for non-commercial purposes is hereby granted * | |
13 | //* without fee, provided that the above copyright notice appears in all * | |
14 | //* copies and that both the copyright notice and this permission notice * | |
15 | //* appear in the supporting documentation. The authors make no claims * | |
16 | //* about the suitability of this software for any purpose. It is * | |
17 | //* provided "as is" without express or implied warranty. * | |
18 | //************************************************************************** | |
5578cf60 | 19 | |
ad7e2f5e | 20 | // @file AliHLTTPCMemHandler.cxx |
21 | // @author U. Frankenfeld, A. Vestbo, C. Loizides, maintained by | |
22 | // Matthias Richter | |
23 | // @date | |
24 | // @brief input interface base class for the TPC tracking code before | |
25 | // migration to the HLT component framework | |
a6c02c85 | 26 | |
0ba35c53 | 27 | #include <cassert> |
a6c02c85 | 28 | #include "AliHLTTPCDigitData.h" |
29 | #include "AliHLTTPCLogging.h" | |
30 | #include "AliHLTTPCTransform.h" | |
a6c02c85 | 31 | #include "AliHLTTPCSpacePointData.h" |
a6c02c85 | 32 | #include "AliHLTTPCMemHandler.h" |
ad7e2f5e | 33 | #include "TMath.h" |
a6c02c85 | 34 | |
a6c02c85 | 35 | using namespace std; |
a6c02c85 | 36 | |
37 | ClassImp(AliHLTTPCMemHandler) | |
38 | ||
39 | AliHLTTPCMemHandler::AliHLTTPCMemHandler() | |
6235cd38 | 40 | : |
41 | fRowMin(0), | |
42 | fRowMax(0), | |
43 | fSlice(0), | |
44 | fPatch(0), | |
45 | fInBinary(NULL), | |
46 | fOutBinary(NULL), | |
47 | fPt(NULL), | |
48 | fSize(0), | |
49 | fIsRandom(kFALSE), | |
50 | fNRandom(0), | |
51 | fNGenerate(0), | |
52 | fNUsed(0), | |
53 | fNDigits(0), | |
54 | fDPt(NULL), | |
55 | fRandomDigits(NULL), | |
56 | fDummy(0) | |
a6c02c85 | 57 | { |
58 | //Constructor | |
a6c02c85 | 59 | Init(0,0); |
a6c02c85 | 60 | ResetROI(); |
61 | } | |
62 | ||
a6c02c85 | 63 | AliHLTTPCMemHandler::~AliHLTTPCMemHandler() |
64 | { | |
65 | //Destructor | |
66 | if(fPt) delete[] fPt; | |
67 | if(fRandomDigits) delete [] fRandomDigits; | |
68 | if(fDPt) delete [] fDPt; | |
69 | } | |
70 | ||
71 | void AliHLTTPCMemHandler::Init(Int_t s,Int_t p, Int_t *r) | |
72 | { | |
73 | //init handler | |
0ba35c53 | 74 | assert(s<fgkNSlice); |
75 | if (s>fgkNSlice) { | |
76 | fSlice=0; | |
77 | fPatch=0; | |
78 | fRowMin=0; | |
79 | fRowMax=0; | |
80 | if (r) *r=0; | |
81 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Init","sector coordinates") | |
82 | <<"Invalid slice no " << s <<ENDLOG; | |
83 | return; | |
84 | } | |
a6c02c85 | 85 | fSlice=s;fPatch=p; |
86 | if(r) { | |
87 | fRowMin=r[0]; | |
88 | fRowMax=r[1]; | |
89 | }else{ | |
90 | fRowMin=AliHLTTPCTransform::GetFirstRow(p); | |
91 | fRowMax=AliHLTTPCTransform::GetLastRow(p); | |
92 | } | |
93 | ResetROI(); | |
94 | } | |
95 | ||
96 | void AliHLTTPCMemHandler::ResetROI() | |
97 | { | |
98 | //Resets the Look-up table for Region of Interest mode. | |
99 | for(Int_t i=fRowMin; i<=fRowMax; i++) | |
100 | { | |
101 | fEtaMinTimeBin[i] = 0; | |
102 | fEtaMaxTimeBin[i] = AliHLTTPCTransform::GetNTimeBins()-1; | |
103 | } | |
104 | } | |
105 | ||
ad7e2f5e | 106 | void AliHLTTPCMemHandler::SetROI(const Float_t *eta,Int_t */*slice*/) |
a6c02c85 | 107 | { |
108 | // Init the Look-up table for the Region of Interest mode. | |
109 | // Here you can specify a certain etaregion, - all data | |
110 | // outside this region will be discarded: | |
111 | // eta[0] = mimium eta | |
112 | // eta[1] = maximum eta | |
113 | // slice[0] = mimumum slice | |
114 | // slice[1] = maximum slice | |
115 | ||
116 | ||
ad7e2f5e | 117 | if(TMath::Abs(eta[1])<.00001) |
a6c02c85 | 118 | { |
119 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetROI","Eta Values") | |
0ba35c53 | 120 | <<"Bad ROI parameters."<<ENDLOG; |
a6c02c85 | 121 | for(Int_t i=fRowMin; i<=fRowMax; i++) |
122 | { | |
123 | fEtaMinTimeBin[i]=0; | |
124 | fEtaMaxTimeBin[i]=0; | |
125 | } | |
126 | return; | |
127 | } | |
128 | ||
129 | for(Int_t i=fRowMin; i<=fRowMax; i++) | |
130 | { | |
131 | Int_t sector,row; | |
132 | Float_t xyz[3]; | |
133 | ||
134 | Float_t thetamax = 2*atan(exp(-1.*eta[1])); | |
135 | ||
136 | xyz[0] = AliHLTTPCTransform::Row2X(i); | |
137 | xyz[1]=0; | |
138 | xyz[2] = xyz[0]/tan(thetamax); | |
139 | AliHLTTPCTransform::Slice2Sector(fSlice,i,sector,row); | |
140 | AliHLTTPCTransform::Local2Raw(xyz,sector,row); | |
141 | ||
142 | fEtaMinTimeBin[i] = (Int_t)xyz[2]; | |
143 | ||
ad7e2f5e | 144 | if(TMath::Abs(eta[0])<.00001) |
a6c02c85 | 145 | fEtaMaxTimeBin[i] = 445; |
146 | else | |
147 | { | |
148 | Float_t thetamin = 2*atan(exp(-1.*eta[0])); | |
149 | xyz[0] = AliHLTTPCTransform::Row2X(i); | |
150 | xyz[1] = AliHLTTPCTransform::GetMaxY(i); | |
151 | Float_t radii = sqrt(pow(xyz[0],2) + pow(xyz[1],2)); | |
152 | xyz[2] = radii/tan(thetamin); | |
153 | AliHLTTPCTransform::Local2Raw(xyz,sector,row); | |
154 | fEtaMaxTimeBin[i] = (Int_t)xyz[2]; | |
155 | } | |
156 | } | |
157 | ||
158 | } | |
159 | ||
160 | Bool_t AliHLTTPCMemHandler::SetBinaryInput(char *name) | |
161 | { | |
162 | //Set the input binary file. | |
163 | fInBinary = fopen(name,"r"); | |
164 | if(!fInBinary){ | |
165 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryInput","File Open") | |
166 | <<"Error opening file "<<name<<ENDLOG; | |
167 | return kFALSE; | |
168 | } | |
169 | return kTRUE; | |
170 | } | |
171 | ||
172 | Bool_t AliHLTTPCMemHandler::SetBinaryInput(FILE *file) | |
173 | { | |
174 | //Set the input binary file. | |
175 | fInBinary = file; | |
176 | if(!fInBinary){ | |
177 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryInput","File Open") | |
178 | <<"Pointer to File = 0x0 "<<ENDLOG; | |
179 | return kFALSE; | |
180 | } | |
181 | return kTRUE; | |
182 | } | |
183 | ||
184 | void AliHLTTPCMemHandler::CloseBinaryInput() | |
185 | { | |
186 | //Close the input file. | |
187 | if(!fInBinary){ | |
188 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CloseBinaryInput","File Close") | |
189 | <<"Nothing to Close"<<ENDLOG; | |
190 | return; | |
191 | } | |
192 | fclose(fInBinary); | |
193 | fInBinary =0; | |
194 | } | |
195 | ||
196 | Bool_t AliHLTTPCMemHandler::SetBinaryOutput(char *name) | |
197 | { | |
198 | //Set the binary output file. | |
199 | fOutBinary = fopen(name,"w"); | |
200 | if(!fOutBinary){ | |
201 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryOutput","File Open") | |
202 | <<"Pointer to File = 0x0 "<<ENDLOG; | |
203 | return kFALSE; | |
204 | } | |
205 | return kTRUE; | |
206 | } | |
207 | ||
208 | Bool_t AliHLTTPCMemHandler::SetBinaryOutput(FILE *file) | |
209 | { | |
210 | //Set the binary output file. | |
211 | fOutBinary = file; | |
212 | if(!fOutBinary){ | |
213 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::SetBinaryOutput","File Open") | |
214 | <<"Pointer to File = 0x0 "<<ENDLOG; | |
215 | return kFALSE; | |
216 | } | |
217 | return kTRUE; | |
218 | } | |
219 | ||
220 | void AliHLTTPCMemHandler::CloseBinaryOutput() | |
221 | { | |
222 | //close binary | |
223 | if(!fOutBinary){ | |
224 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CloseBinaryOutPut","File Close") | |
225 | <<"Nothing to Close"<<ENDLOG; | |
226 | return; | |
227 | } | |
228 | fclose(fOutBinary); | |
229 | fOutBinary =0; | |
230 | } | |
231 | ||
232 | UInt_t AliHLTTPCMemHandler::GetFileSize() | |
233 | { | |
234 | //Returns the file size in bytes of the input file. | |
235 | if(!fInBinary){ | |
236 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetFileSize","File") | |
237 | <<"No Input File"<<ENDLOG; | |
238 | return 0; | |
239 | } | |
240 | fseek(fInBinary,0,SEEK_END); | |
9052f917 | 241 | long size=ftell(fInBinary); |
a6c02c85 | 242 | rewind(fInBinary); |
9052f917 | 243 | if (size<0) return 0; |
244 | return (UInt_t)size; | |
a6c02c85 | 245 | } |
246 | ||
247 | Byte_t *AliHLTTPCMemHandler::Allocate() | |
248 | { | |
249 | //Allocate | |
250 | return Allocate(GetFileSize()); | |
251 | } | |
252 | ||
a6c02c85 | 253 | Byte_t *AliHLTTPCMemHandler::Allocate(UInt_t size) |
254 | { | |
255 | //Allocate memory of size in bytes. | |
256 | if(fPt){ | |
257 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Allocate","Memory") | |
258 | <<"Delete Memory"<<ENDLOG; | |
259 | Free(); | |
260 | } | |
261 | fPt = new Byte_t[size]; | |
262 | fSize = size; | |
263 | memset(fPt,0,fSize); | |
264 | LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Allocate","Memory") | |
265 | <<AliHLTTPCLog::kDec<<"Allocate "<<size<<" Bytes of Memory"<<ENDLOG; | |
266 | return fPt; | |
267 | } | |
268 | ||
269 | void AliHLTTPCMemHandler::Free() | |
270 | { | |
271 | //Clear the memory, if allocated. | |
272 | if(!fPt){ | |
273 | // LOG(AliHLTTPCLog::kInformational,"AliHLTTPCMemHandler::Free","Memory") | |
274 | // <<"No Memory allocated - can't Free"<<ENDLOG; | |
275 | return; | |
276 | } | |
277 | delete[] fPt; | |
278 | fPt = 0; | |
279 | fSize =0; | |
280 | } | |
281 | ||
282 | ///////////////////////////////////////// Random | |
283 | void AliHLTTPCMemHandler::SetRandomSeed() | |
284 | { | |
285 | //If you are adding random data to the original data. | |
286 | time_t *tp=0; | |
287 | SetRandomSeed(time(tp)); | |
288 | } | |
289 | ||
290 | void AliHLTTPCMemHandler::SetRandomCluster(Int_t maxnumber) | |
291 | { | |
292 | //If you are adding random data to the original data. | |
293 | ||
294 | fIsRandom = kTRUE; | |
295 | fNRandom = maxnumber; | |
296 | fNDigits = 0; | |
297 | if(fRandomDigits) delete [] fRandomDigits; | |
298 | fRandomDigits = new AliHLTTPCRandomDigitData[fNRandom*9]; | |
299 | if(fDPt) delete [] fDPt; | |
300 | fDPt = new AliHLTTPCRandomDigitData *[fNRandom*9]; | |
301 | } | |
302 | ||
303 | void AliHLTTPCMemHandler::QSort(AliHLTTPCRandomDigitData **a, Int_t first, Int_t last) | |
304 | { | |
305 | ||
306 | // Sort array of AliHLTTPCRandomDigitData pointers using a quicksort algorithm. | |
307 | // Uses CompareDigits() to compare objects. | |
308 | // Thanks to Root! | |
309 | ||
310 | static AliHLTTPCRandomDigitData *tmp; | |
311 | static int i; // "static" to save stack space | |
312 | int j; | |
313 | ||
314 | while (last - first > 1) { | |
315 | i = first; | |
316 | j = last; | |
317 | for (;;) { | |
318 | while (++i < last && CompareDigits(a[i], a[first]) < 0) | |
319 | ; | |
320 | while (--j > first && CompareDigits(a[j], a[first]) > 0) | |
321 | ; | |
322 | if (i >= j) | |
323 | break; | |
324 | ||
325 | tmp = a[i]; | |
326 | a[i] = a[j]; | |
327 | a[j] = tmp; | |
328 | } | |
329 | if (j == first) { | |
330 | ++first; | |
331 | continue; | |
332 | } | |
333 | tmp = a[first]; | |
334 | a[first] = a[j]; | |
335 | a[j] = tmp; | |
336 | ||
337 | if (j - first < last - (j + 1)) { | |
338 | QSort(a, first, j); | |
339 | first = j + 1; // QSort(j + 1, last); | |
340 | } else { | |
341 | QSort(a, j + 1, last); | |
342 | last = j; // QSort(first, j); | |
343 | } | |
344 | } | |
345 | } | |
346 | ||
347 | UInt_t AliHLTTPCMemHandler::GetRandomSize() const | |
348 | { | |
349 | //get random size | |
350 | Int_t nrandom = 0; | |
351 | for(Int_t r=fRowMin;r<=fRowMax;r++){ | |
352 | Int_t npad=AliHLTTPCTransform::GetNPads(r); | |
353 | nrandom += Int_t (fNGenerate * ((Double_t) npad/141.)); | |
354 | } | |
355 | return 9 * nrandom * sizeof(AliHLTTPCDigitData); | |
356 | } | |
357 | ||
a6c02c85 | 358 | void AliHLTTPCMemHandler::DigitizePoint(Int_t row, Int_t pad, |
359 | Int_t time,Int_t charge) | |
360 | { | |
361 | //Making one single random cluster. | |
362 | for(Int_t j=-1;j<2;j++){ | |
363 | for(Int_t k=-1;k<2;k++){ | |
364 | Int_t dcharge = charge; | |
365 | if(j) dcharge /=2; | |
366 | if(k) dcharge /=2; | |
367 | if(dcharge<10) continue; | |
368 | Int_t dpad = j + pad; | |
369 | Int_t dtime = k + time; | |
370 | ||
371 | if(dpad<0||dpad>=AliHLTTPCTransform::GetNPads(row)) continue; | |
372 | if(dtime<0||dtime>=AliHLTTPCTransform::GetNTimeBins()) continue; | |
373 | ||
374 | fRandomDigits[fNDigits].fCharge = dcharge; | |
375 | fRandomDigits[fNDigits].fRow = row; | |
376 | fRandomDigits[fNDigits].fPad = dpad; | |
377 | fRandomDigits[fNDigits].fTime = dtime; | |
378 | fDPt[fNDigits] = &fRandomDigits[fNDigits]; | |
379 | fNDigits++; | |
380 | } | |
381 | } | |
382 | } | |
383 | ||
384 | ///////////////////////////////////////// Digit IO | |
5578cf60 | 385 | Bool_t AliHLTTPCMemHandler::Memory2BinaryFile(UInt_t nrow,AliHLTTPCDigitRowData *data) |
a6c02c85 | 386 | { |
387 | //Write data to the outputfile as is. No run-length encoding is done. | |
5578cf60 | 388 | |
a6c02c85 | 389 | if(!fOutBinary){ |
390 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File") | |
391 | <<"No Output File"<<ENDLOG; | |
392 | return kFALSE; | |
393 | } | |
394 | if(!data){ | |
395 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory") | |
396 | <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG; | |
397 | return kFALSE; | |
398 | } | |
399 | ||
400 | AliHLTTPCDigitRowData *rowPt = data; | |
401 | Int_t outsize = 0; | |
402 | for(UInt_t i=0;i<nrow;i++){ | |
403 | Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit | |
404 | + sizeof(AliHLTTPCDigitRowData); | |
405 | outsize += size; | |
406 | fwrite(rowPt,size,1,fOutBinary); | |
407 | Byte_t *bytePt =(Byte_t *) rowPt; | |
408 | bytePt += size; | |
409 | rowPt = (AliHLTTPCDigitRowData *) bytePt; | |
410 | } | |
411 | LOG(AliHLTTPCLog::kDebug,"AliHLTTPCMemHandler::Memory2Binary","Memory") | |
412 | <<AliHLTTPCLog::kDec<<"Wrote "<<outsize<<" Bytes to Memory (" | |
413 | <<nrow<<" Rows)"<<ENDLOG; | |
414 | return kTRUE; | |
415 | } | |
416 | ||
a6c02c85 | 417 | void AliHLTTPCMemHandler::AddData(AliHLTTPCDigitData *data,UInt_t & ndata, |
418 | UInt_t /*row*/,UShort_t pad,UShort_t time,UShort_t charge) const | |
419 | { | |
420 | //add some data | |
421 | data[ndata].fPad = pad; | |
422 | data[ndata].fTime = time; | |
423 | data[ndata].fCharge = charge; | |
424 | ndata++; | |
425 | } | |
426 | ||
427 | void AliHLTTPCMemHandler::AddRandom(AliHLTTPCDigitData *data, UInt_t & ndata) | |
428 | { | |
429 | //add some random data | |
430 | data[ndata].fPad = fDPt[fNUsed]->fPad; | |
431 | data[ndata].fTime = fDPt[fNUsed]->fTime; | |
432 | data[ndata].fCharge = fDPt[fNUsed]->fCharge; | |
433 | ndata++; | |
434 | fNUsed++; | |
435 | } | |
436 | ||
437 | void AliHLTTPCMemHandler::MergeDataRandom(AliHLTTPCDigitData *data, UInt_t & ndata, | |
438 | UInt_t row, UShort_t pad, UShort_t time, UShort_t charge) | |
439 | { | |
440 | //merge random data | |
441 | data[ndata].fPad = pad; | |
442 | data[ndata].fTime = time; | |
443 | data[ndata].fCharge = charge; | |
444 | while(ComparePoints(row,pad,time)==0){ | |
445 | Int_t ch = data[ndata].fCharge + fDPt[fNUsed]->fCharge; | |
446 | if(charge>=AliHLTTPCTransform::GetADCSat()) ch = AliHLTTPCTransform::GetADCSat(); | |
447 | data[ndata].fCharge = ch; | |
448 | fNUsed++; | |
449 | } | |
450 | ndata++; | |
451 | } | |
452 | ||
453 | void AliHLTTPCMemHandler::AddDataRandom(AliHLTTPCDigitData *data, UInt_t & ndata, | |
454 | UInt_t row, UShort_t pad, UShort_t time, UShort_t charge) | |
455 | { | |
456 | //add data random | |
457 | Int_t action; | |
458 | while((action=ComparePoints(row,pad,time))==1){ | |
459 | AddRandom(data,ndata); | |
460 | } | |
461 | if(action==0){ | |
462 | MergeDataRandom(data,ndata,row,pad,time,charge); | |
463 | } | |
464 | if(action<0){ | |
465 | AddData(data,ndata,row,pad,time,charge); | |
466 | } | |
467 | } | |
468 | ||
469 | void AliHLTTPCMemHandler::Write(UInt_t *comp, UInt_t & index, | |
470 | UInt_t & subindex, UShort_t value) const | |
471 | { | |
472 | //write compressed data | |
473 | UInt_t shift[3] = {0,10,20}; | |
474 | if(subindex==0) comp[index] =0; //clean up memory | |
475 | comp[index] |= (value&0x03ff)<<shift[subindex]; | |
476 | if(subindex == 2){ | |
477 | subindex = 0; | |
478 | index++; | |
479 | } | |
480 | else subindex++; | |
481 | } | |
482 | ||
483 | UShort_t AliHLTTPCMemHandler::Read(UInt_t *comp, UInt_t & index, UInt_t & subindex) const | |
484 | { | |
485 | //read compressed data | |
486 | UInt_t shift[3] = {0,10,20}; | |
487 | UShort_t value = (comp[index]>>shift[subindex])&0x03ff; | |
488 | if(subindex == 2){ | |
489 | subindex = 0; | |
490 | index++; | |
491 | } | |
492 | else subindex++; | |
493 | ||
494 | return value; | |
495 | } | |
496 | ||
ad7e2f5e | 497 | UShort_t AliHLTTPCMemHandler::Test(const UInt_t *comp, |
a6c02c85 | 498 | UInt_t index, UInt_t subindex) const |
499 | { | |
500 | //supi dupi test | |
501 | UInt_t shift[3] = {0,10,20}; | |
502 | return (comp[index]>>shift[subindex])&0x03ff; | |
503 | } | |
504 | ||
505 | Int_t AliHLTTPCMemHandler::Memory2CompMemory(UInt_t nrow, | |
506 | AliHLTTPCDigitRowData *data,UInt_t *comp) | |
507 | { | |
508 | //Performs run-length encoding on data stored in memory pointed to by data. | |
509 | //The compressed data is written to comp. | |
510 | if(!comp){ | |
511 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2CompMemory","Memory") | |
512 | <<"Pointer to compressed data = 0x0 "<<ENDLOG; | |
513 | return 0; | |
514 | } | |
515 | if(!data){ | |
516 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2CompMemory","Memory") | |
517 | <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG; | |
518 | return 0; | |
519 | } | |
520 | AliHLTTPCDigitRowData *rowPt = data; | |
521 | UInt_t index=0; | |
522 | UInt_t subindex=0; | |
523 | ||
524 | for(UInt_t i=0;i<nrow;i++){ | |
525 | UShort_t value = rowPt->fRow; | |
526 | Write(comp,index,subindex,value); | |
527 | UShort_t maxpad=0; | |
528 | UShort_t npad=0; | |
529 | Int_t ddd[1000]; | |
530 | for(Int_t d=0;d<200;d++) ddd[d]=0; | |
531 | for(UInt_t dig=0;dig<rowPt->fNDigit;dig++){ | |
532 | if(rowPt->fDigitData[dig].fPad <200){ | |
533 | ddd[rowPt->fDigitData[dig].fPad]++; | |
534 | } | |
535 | } | |
536 | for(Int_t d=0;d<200;d++){ | |
537 | if(ddd[d]){ | |
538 | npad++; | |
539 | maxpad =d; | |
540 | } | |
541 | } | |
542 | Write(comp,index,subindex,npad); | |
543 | UInt_t digit=0; | |
544 | for(UShort_t pad=0;pad <= maxpad;pad++){ | |
545 | if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad) | |
546 | continue; | |
547 | Write(comp,index,subindex,pad); | |
548 | // write zero if time != 0 | |
549 | if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){ | |
550 | if(rowPt->fDigitData[digit].fTime>0){ | |
551 | Write(comp,index,subindex,0); | |
552 | Write(comp,index,subindex,rowPt->fDigitData[digit].fTime); | |
553 | } | |
554 | } | |
555 | while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){ | |
556 | UShort_t charge = rowPt->fDigitData[digit].fCharge; | |
557 | if(charge>=1023){ | |
558 | charge=1023; | |
559 | } | |
560 | Write(comp,index,subindex,charge); | |
561 | if(digit+1<rowPt->fNDigit&&rowPt->fDigitData[digit+1].fPad == pad){ | |
562 | if(rowPt->fDigitData[digit].fTime +1 != | |
563 | rowPt->fDigitData[digit+1].fTime){ | |
564 | Write(comp,index,subindex,0); | |
565 | UShort_t nzero = rowPt->fDigitData[digit+1].fTime - | |
566 | (rowPt->fDigitData[digit].fTime +1); | |
567 | Write(comp,index,subindex,nzero); | |
568 | } | |
569 | } | |
570 | digit++; | |
571 | } | |
572 | Write(comp,index,subindex,0); | |
573 | Write(comp,index,subindex,0); | |
574 | } | |
575 | ||
576 | Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+ | |
577 | sizeof(AliHLTTPCDigitRowData); | |
578 | Byte_t *bytePt =(Byte_t *) rowPt; | |
579 | bytePt += size; | |
580 | rowPt = (AliHLTTPCDigitRowData *) bytePt; | |
581 | } | |
582 | while(subindex) | |
583 | Write(comp,index,subindex,0); | |
584 | return index * sizeof(UInt_t); | |
585 | } | |
586 | ||
a6c02c85 | 587 | UInt_t AliHLTTPCMemHandler::GetCompMemorySize(UInt_t nrow,AliHLTTPCDigitRowData *data) const |
588 | { | |
589 | //Return the size of RLE data, after compressing data. | |
590 | ||
591 | if(!data){ | |
592 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetCompMemorySize","Memory") | |
593 | <<"Pointer to AliHLTTPCDigitRowData = 0x0 "<<ENDLOG; | |
594 | return 0; | |
595 | } | |
596 | AliHLTTPCDigitRowData *rowPt = data; | |
597 | UInt_t index=0; | |
598 | ||
599 | for(UInt_t i=0;i<nrow;i++){ | |
600 | index++; | |
601 | UShort_t maxpad=0; | |
602 | UShort_t npad=0; | |
603 | Int_t ddd[1000]; | |
604 | for(Int_t d=0;d<200;d++) ddd[d]=0; | |
605 | for(UInt_t dig=0;dig<rowPt->fNDigit;dig++){ | |
606 | if(rowPt->fDigitData[dig].fPad <200){ | |
607 | ddd[rowPt->fDigitData[dig].fPad]++; | |
608 | } | |
609 | } | |
610 | for(Int_t d=0;d<200;d++){ | |
611 | if(ddd[d]){ | |
612 | npad++; | |
613 | maxpad =d; | |
614 | } | |
615 | } | |
616 | index++; | |
617 | UInt_t digit=0; | |
618 | for(UShort_t pad=0;pad <= maxpad;pad++){ | |
619 | if(digit>=rowPt->fNDigit || rowPt->fDigitData[digit].fPad != pad) | |
620 | continue; | |
621 | index++; | |
622 | // write zero if time != 0 | |
623 | if(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){ | |
624 | if(rowPt->fDigitData[digit].fTime>0){ | |
625 | index++; | |
626 | index++; | |
627 | } | |
628 | } | |
629 | while(digit<rowPt->fNDigit && rowPt->fDigitData[digit].fPad == pad){ | |
630 | index++; | |
631 | if(digit+1<rowPt->fNDigit&&rowPt->fDigitData[digit+1].fPad == pad){ | |
632 | if(rowPt->fDigitData[digit].fTime +1 != | |
633 | rowPt->fDigitData[digit+1].fTime){ | |
634 | index++; | |
635 | index++; | |
636 | } | |
637 | } | |
638 | digit++; | |
639 | } | |
640 | index++; | |
641 | index++; | |
642 | } | |
643 | ||
644 | Int_t size = sizeof(AliHLTTPCDigitData) * rowPt->fNDigit+ | |
645 | sizeof(AliHLTTPCDigitRowData); | |
646 | Byte_t *bytePt =(Byte_t *) rowPt; | |
647 | bytePt += size; | |
648 | rowPt = (AliHLTTPCDigitRowData *) bytePt; | |
649 | } | |
650 | while(index%3) | |
651 | index++; | |
652 | return (index/3) * sizeof(UInt_t); | |
653 | } | |
654 | ||
655 | UInt_t AliHLTTPCMemHandler::GetMemorySize(UInt_t nrow,UInt_t *comp) const | |
656 | { | |
657 | //get memory size | |
658 | if(!comp){ | |
659 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetMemorySize","Memory") | |
660 | <<"Pointer to compressed data = 0x0 "<<ENDLOG; | |
661 | return 0; | |
662 | } | |
663 | Int_t outsize=0; | |
664 | ||
665 | UInt_t index=0; | |
666 | UInt_t subindex=0; | |
667 | ||
668 | for(UInt_t i=0;i<nrow;i++){ | |
669 | UInt_t ndigit=0; | |
670 | Read(comp,index,subindex); | |
671 | UShort_t npad = Read(comp,index,subindex); | |
672 | for(UShort_t p=0;p<npad;p++){ | |
673 | Read(comp,index,subindex); | |
674 | if(Test(comp,index,subindex)==0){ | |
675 | Read(comp,index,subindex); | |
676 | if(Read(comp,index,subindex)== 0) continue; | |
677 | } | |
678 | for(;;){ | |
679 | while(Read(comp,index,subindex)!=0) ndigit++; | |
680 | if(Read(comp,index,subindex)==0) break; | |
681 | } | |
682 | } | |
683 | Int_t size = sizeof(AliHLTTPCDigitData) * ndigit+ | |
684 | sizeof(AliHLTTPCDigitRowData); | |
685 | outsize += size; | |
686 | } | |
687 | ||
688 | return outsize; | |
689 | } | |
690 | ||
691 | UInt_t AliHLTTPCMemHandler::GetNRow(UInt_t *comp,UInt_t size) | |
692 | { | |
693 | //get number of rows | |
694 | if(!comp){ | |
695 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::GetNRow","Memory") | |
696 | <<"Pointer to compressed data = 0x0 "<<ENDLOG; | |
697 | return 0; | |
698 | } | |
699 | size = size /4; | |
700 | UInt_t nrow=0; | |
701 | UInt_t index=0; | |
702 | UInt_t subindex=0; | |
703 | while(index<size-1){ //don't start with last word | |
704 | nrow++; | |
705 | UInt_t ndigit=0; | |
706 | Read(comp,index,subindex); | |
707 | UShort_t npad = Read(comp,index,subindex); | |
708 | for(UShort_t p=0;p<npad;p++){ | |
709 | Read(comp,index,subindex); | |
710 | if(Test(comp,index,subindex)==0){ | |
711 | Read(comp,index,subindex); | |
712 | if(Read(comp,index,subindex)==0)continue; | |
713 | } | |
714 | for(;;){ | |
715 | while(Read(comp,index,subindex)!=0) ndigit++; | |
716 | if(Read(comp,index,subindex)==0) break; | |
717 | } | |
718 | } | |
719 | } | |
720 | if(index==size-1){ //last word | |
721 | if(subindex<2){ | |
722 | if(Read(comp,index,subindex)!=0) nrow++; | |
723 | } | |
724 | } | |
725 | return nrow; | |
726 | } | |
727 | ||
728 | Bool_t AliHLTTPCMemHandler::CompMemory2CompBinary(UInt_t nrow,UInt_t *comp, | |
9052f917 | 729 | UInt_t size) |
a6c02c85 | 730 | { |
731 | //Write the RLE data in comp to the output file. | |
732 | ||
733 | if(!fOutBinary){ | |
734 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","File") | |
735 | <<"No Output File"<<ENDLOG; | |
736 | return kFALSE; | |
737 | } | |
738 | if(!comp){ | |
739 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","Memory") | |
740 | <<"Pointer to compressed data = 0x0 "<<ENDLOG; | |
741 | return kFALSE; | |
742 | } | |
743 | if(size==0) | |
744 | size=GetMemorySize(nrow,comp); | |
745 | if(!size){ | |
746 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::CompMemory2CompBinary","Memory") | |
747 | <<"Memory size = 0 "<<ENDLOG; | |
748 | return kFALSE; | |
749 | } | |
750 | UInt_t length = size/sizeof(UInt_t); | |
751 | fwrite(&length,sizeof(UInt_t),1,fOutBinary); | |
752 | fwrite(comp,size,1,fOutBinary); | |
753 | return kTRUE; | |
754 | } | |
755 | ||
a6c02c85 | 756 | |
757 | Bool_t AliHLTTPCMemHandler::Memory2CompBinary(UInt_t nrow,AliHLTTPCDigitRowData *data) | |
758 | { | |
759 | //Perform RLE on the data, and write it to the output file. | |
760 | Bool_t out = kTRUE; | |
761 | AliHLTTPCMemHandler * handler = new AliHLTTPCMemHandler(); | |
762 | UInt_t size = GetCompMemorySize(nrow,data); | |
763 | UInt_t *comp =(UInt_t *)handler->Allocate(size); | |
764 | Memory2CompMemory(nrow,data,comp); | |
765 | CompMemory2CompBinary(nrow,comp,size); | |
766 | handler->Free(); | |
767 | delete handler; | |
768 | return out; | |
769 | } | |
770 | ||
771 | ||
772 | ///////////////////////////////////////// Point IO | |
773 | Bool_t AliHLTTPCMemHandler::Memory2Binary(UInt_t npoint,AliHLTTPCSpacePointData *data) | |
774 | { | |
775 | //Writing spacepoints stored in data to the outputfile. | |
776 | if(!fOutBinary){ | |
777 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","File") | |
778 | <<"No Output File"<<ENDLOG; | |
779 | return kFALSE; | |
780 | } | |
781 | if(!data){ | |
782 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Memory2Binary","Memory") | |
783 | <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG; | |
784 | return kFALSE; | |
785 | } | |
786 | UInt_t size = npoint*sizeof(AliHLTTPCSpacePointData); | |
787 | fwrite(data,size,1,fOutBinary); | |
788 | ||
789 | return kTRUE; | |
790 | } | |
791 | ||
792 | Bool_t AliHLTTPCMemHandler::Transform(UInt_t npoint,AliHLTTPCSpacePointData *data,Int_t slice) | |
793 | { | |
794 | //Transform the space points in data, to global coordinates in slice. | |
795 | if(!data){ | |
796 | LOG(AliHLTTPCLog::kWarning,"AliHLTTPCMemHandler::Transform","Memory") | |
797 | <<"Pointer to AliHLTTPCSpacePointData = 0x0 "<<ENDLOG; | |
798 | return kFALSE; | |
799 | } | |
800 | ||
801 | for(UInt_t i=0;i<npoint;i++){ | |
802 | Float_t xyz[3]; | |
803 | xyz[0] = data[i].fX; | |
804 | xyz[1] = data[i].fY; | |
805 | xyz[2] = data[i].fZ; | |
806 | AliHLTTPCTransform::Local2Global(xyz,slice); | |
807 | data[i].fX = xyz[0]; | |
808 | data[i].fY = xyz[1]; | |
809 | data[i].fZ = xyz[2]; | |
810 | } | |
811 | return kTRUE; | |
812 | } | |
813 | ||
a6c02c85 | 814 | void AliHLTTPCMemHandler::UpdateRowPointer(AliHLTTPCDigitRowData *&tempPt) |
815 | { | |
816 | //Update the data pointer to the next padrow in memory. | |
817 | ||
80d83a65 | 818 | Byte_t *tmp = (Byte_t*)tempPt; |
a6c02c85 | 819 | Int_t size = sizeof(AliHLTTPCDigitRowData) + tempPt->fNDigit*sizeof(AliHLTTPCDigitData); |
820 | tmp += size; | |
80d83a65 | 821 | tempPt = (AliHLTTPCDigitRowData*)tmp; |
a6c02c85 | 822 | } |
823 | ||
824 | Int_t AliHLTTPCMemHandler::ComparePoints(UInt_t /*row*/,UShort_t pad,UShort_t time) const | |
825 | { | |
826 | //compare two points | |
827 | if(fNUsed>=fNDigits) return -2; | |
828 | ||
829 | if(pad==fDPt[fNUsed]->fPad&&time==fDPt[fNUsed]->fTime) return 0; | |
830 | ||
831 | if(pad<fDPt[fNUsed]->fPad) return -1; | |
832 | if(pad==fDPt[fNUsed]->fPad&&time<fDPt[fNUsed]->fTime) return -1; | |
833 | ||
834 | return 1; | |
835 | } | |
836 | ||
ad7e2f5e | 837 | Int_t AliHLTTPCMemHandler::CompareDigits(const AliHLTTPCRandomDigitData *a,const AliHLTTPCRandomDigitData *b) const |
a6c02c85 | 838 | { |
839 | //compare two digits | |
840 | if(a->fPad==b->fPad && a->fTime == b->fTime) return 0; | |
841 | ||
842 | if(a->fPad<b->fPad) return -1; | |
843 | if(a->fPad==b->fPad && a->fTime<b->fTime) return -1; | |
844 | ||
845 | return 1; | |
846 | } |