Adaption to new fluka common blocks (E. Futo)
[u/mrichter/AliRoot.git] / TRD / AliTRDrawData.cxx
CommitLineData
5990c064 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/*
17$Log$
a2cb5b3d 18Revision 1.2 2002/10/14 14:57:44 hristov
19Merging the VirtualMC branch to the main development branch (HEAD)
20
b9d0a01d 21Revision 1.1.2.1 2002/10/11 07:26:37 hristov
22Updating VirtualMC to v3-09-02
23
24Revision 1.1 2002/09/13 14:33:52 cblume
25Add conversion class to produce fake raw data
26
5990c064 27*/
28
29///////////////////////////////////////////////////////////////////////////////
30// //
31// TRD raw data conversion class //
32// //
33///////////////////////////////////////////////////////////////////////////////
34
a2cb5b3d 35#include <Riostream.h>
5990c064 36
37#include "AliTRDrawData.h"
38#include "AliTRDdigitsManager.h"
39#include "AliTRDgeometryFull.h"
40#include "AliTRDparameter.h"
41#include "AliTRDdataArrayI.h"
42#include "AliTRDarrayI.h"
43
44ClassImp(AliTRDrawData)
45
46//_____________________________________________________________________________
47AliTRDrawData::AliTRDrawData():TObject()
48{
49
50 fDebug = 0;
51 fDigitsManager = NULL;
52
53}
54
55//_____________________________________________________________________________
56AliTRDrawData::AliTRDrawData(const AliTRDrawData &r)
57{
58 //
59 // AliTRDrawData copy constructor
60 //
61
62 ((AliTRDrawData &) r).Copy(*this);
63
64}
65
66//_____________________________________________________________________________
67AliTRDrawData::~AliTRDrawData()
68{
69 //
70 // Destructor
71 //
72
73 if (fDigitsManager) {
74 delete fDigitsManager;
75 fDigitsManager = NULL;
76 }
77
78}
79
80//_____________________________________________________________________________
81AliTRDrawData &AliTRDrawData::operator=(const AliTRDrawData &r)
82{
83 //
84 // Assignment operator
85 //
86
87 if (this != &r) ((AliTRDrawData &) r).Copy(*this);
88 return *this;
89
90}
91
92//_____________________________________________________________________________
93void AliTRDrawData::Copy(TObject &r)
94{
95 //
96 // Copy function
97 //
98
99 ((AliTRDrawData &) r).fDebug = fDebug;
100 ((AliTRDrawData &) r).fDigitsManager = NULL;
101
102}
103
104//_____________________________________________________________________________
105Bool_t AliTRDrawData::OpenInput(const Char_t *name)
106{
107 //
108 // Opens a ROOT-file with the TRD digits
109 //
110
111 // Create the digits manager
112 if (fDigitsManager) {
113 delete fDigitsManager;
114 }
115 fDigitsManager = new AliTRDdigitsManager();
116 fDigitsManager->SetDebug(fDebug);
117
118 // Open the input file
119 return fDigitsManager->Open(name);
120
121}
122
123//_____________________________________________________________________________
124Bool_t AliTRDrawData::Digit2Raw(const Char_t *name1, const Char_t *name2)
125{
126 //
127 // Convert the digits to raw data byte stream. The output is written
128 // into the the binary files <name1> and <name2>.
129 //
130 // The pseudo raw data format is currently defined like this:
131 //
132 // LDC header (8 bytes)
133 // FLAG
134 // LDC no.
135 // Number of detectors with data (not yet implemented)
136 // 5 empty bytes
137 //
138 // Subevent (= single chamber) header (8 bytes)
139 // FLAG
140 // Detector number (2 bytes)
141 // Number of data bytes (2 bytes)
142 // Number of pads with data (2 bytes)
143 // 1 empty byte
144 //
145 // Data bank
146 //
147
148 const Int_t kLDCHeaderLength = 8;
149 const Int_t kSubeventHeaderLength = 8;
150
151 const Int_t kLDCDummyFlag = 0xAA;
152 const Int_t kSubeventDummyFlag = 0xBB;
153
154 int headerLDC[2];
155 int headerSubevent[2];
156
157 Int_t ntotalbyte[2] = { 0 };
158 Int_t nbyte = 0;
159 Int_t npads = 0;
160 unsigned char *byte_p;
161 unsigned char *header_p;
162
163 AliTRDgeometryFull *geo = new AliTRDgeometryFull();
164 AliTRDparameter *par = new AliTRDparameter("TRDparameter"
165 ,"TRD parameter class");
166 AliTRDdataArrayI *digits;
167
168 if (fDebug) {
169 Info("Digit2Raw","Open the LDC output files %s, %s"
170 ,name1,name2);
171 }
172 ofstream *outputFile1 = new ofstream(name1, ios::out | ios::binary);
173 ofstream *outputFile2 = new ofstream(name2, ios::out | ios::binary);
174 ofstream *outputFile;
175
176 if (!fDigitsManager) {
177 Error("Digit2Raw","No input file open\n");
178 return kFALSE;
179 }
180
181 // Read in the digit arrays
182 if (!fDigitsManager->ReadDigits()) {
183 return kFALSE;
184 }
185
186 // Count the number of chambers with data
187 Int_t ndetLDC0 = 0;
188 Int_t ndetLDC1 = 0;
189
190 if (fDebug > 1) {
191 Info("Digit2Raw","Write the LDC headers");
192 }
193
194 // Write the LDC header 1
195 byte_p = (unsigned char *) headerLDC;
196 header_p = byte_p;
197 *byte_p++ = kLDCDummyFlag;
198 *byte_p++ = 1;
199 *byte_p++ = ndetLDC0;
200 *byte_p++ = 0;
201 *byte_p++ = 0;
202 *byte_p++ = 0;
203 *byte_p++ = 0;
204 *byte_p++ = 0;
205 outputFile1->write(header_p,kLDCHeaderLength);
206 ntotalbyte[0] += kLDCHeaderLength;
207
208 if (fDebug > 1) {
209 Info("Digit2Raw","LDC header 0 = %d, %d",headerLDC[0],headerLDC[1]);
210 }
211
212 // Write the LDC header 1
213 byte_p = (unsigned char *) headerLDC;
214 header_p = byte_p;
215 *byte_p++ = kLDCDummyFlag;
216 *byte_p++ = 2;
217 *byte_p++ = ndetLDC1;
218 *byte_p++ = 0;
219 *byte_p++ = 0;
220 *byte_p++ = 0;
221 *byte_p++ = 0;
222 *byte_p++ = 0;
223 outputFile2->write(header_p,kLDCHeaderLength);
224 ntotalbyte[1] += kLDCHeaderLength;
225
226 if (fDebug > 1) {
227 Info("Digit2Raw","LDC header 1 = %d, %d",headerLDC[0],headerLDC[1]);
228 }
229
230 // Loop through all detectors
231 for (Int_t det = 0; det < AliTRDgeometry::Ndet(); det++) {
232
233 Int_t cham = geo->GetChamber(det);
234 Int_t plan = geo->GetPlane(det);
235 Int_t sect = geo->GetSector(det);
236 Int_t rowMax = par->GetRowMax(plan,cham,sect);
237 Int_t colMax = par->GetColMax(plan);
238 Int_t timeMax = par->GetTimeMax();
239 Int_t bufferMax = rowMax*colMax*timeMax;
240 int *buffer = new int[bufferMax];
241
242 npads = 0;
243 nbyte = 0;
244 byte_p = (unsigned char *) buffer;
245
246 // Determine the LDC (resp. output file)
247 Int_t ldc;
248 if (sect < 9) {
249 outputFile = outputFile1;
250 ldc = 0;
251 }
252 else {
253 outputFile = outputFile2;
254 ldc = 1;
255 }
256
257 // Get the digits array
258 digits = fDigitsManager->GetDigits(det);
259 digits->Expand();
260
261 // Loop through the detector pixel
262 for (Int_t col = 0; col < colMax; col++) {
263 for (Int_t row = 0; row < rowMax; row++) {
264
265 // Check whether data exists for this pad
266 Bool_t dataflag = kFALSE;
267 for (Int_t time = 0; time < timeMax; time++) {
268 Int_t data = digits->GetDataUnchecked(row,col,time);
269 if (data) {
270 dataflag = kTRUE;
271 break;
272 }
273 }
274
275 if (dataflag) {
276
277 npads++;
278
279 // The pad row number
280 *byte_p++ = row + 1;
281 // The pad column number
282 *byte_p++ = col + 1;
283 nbyte += 2;
284
285 Int_t nzero = 0;
286 for (Int_t time = 0; time < timeMax; time++) {
287
288 Int_t data = digits->GetDataUnchecked(row,col,time);
289
290 if (!data) {
291 nzero++;
292 if ((nzero == 256) ||
293 (time == timeMax-1)) {
294 *byte_p++ = 0;
295 *byte_p++ = nzero-1;
296 nbyte += 2;
297 nzero = 0;
298 }
299 }
300 else {
301 if (nzero) {
302 *byte_p++ = 0;
303 *byte_p++ = nzero-1;
304 nbyte += 2;
305 nzero = 0;
306 }
307 // High byte (MSB always set)
308 *byte_p++ = ((data >> 8) | 128);
309 // Low byte
310 *byte_p++ = (data & 0xff);
311 nbyte += 2;
312 }
313
314 }
315
316 }
317
318 }
319
320 }
321
322 // Fill the end of the buffer with zeros
323 while (nbyte % 4) {
324 *byte_p++ = 0;
325 nbyte++;
326 }
327
328 if (fDebug > 1) {
329 Info("Digit2Raw","LDC = %d, det = %d, nbyte = %d (%d)",ldc,det,nbyte,bufferMax);
330 }
331
332 // Write the subevent header
333 byte_p = (unsigned char *) headerSubevent;
334 header_p = byte_p;
335 *byte_p++ = kSubeventDummyFlag;
336 *byte_p++ = (det & 0xff);
337 *byte_p++ = (det >> 8);
338 *byte_p++ = (nbyte & 0xff);
339 *byte_p++ = (nbyte >> 8);
340 *byte_p++ = (npads & 0xff);
341 *byte_p++ = (npads >> 8);
342 *byte_p++ = 0;
343 outputFile->write(header_p,kSubeventHeaderLength);
344
345 // Write the buffer to the file
346 byte_p = (unsigned char *) buffer;
347 outputFile->write(byte_p,nbyte);
348
349 ntotalbyte[ldc] += nbyte + kSubeventHeaderLength;
350
351 delete buffer;
352
353 }
354
355 if (fDebug) {
356 Info("Digit2Raw","Total size: LDC0 = %d, LDC1 = %d",ntotalbyte[0],ntotalbyte[1]);
357 }
358
359 outputFile1->close();
360 outputFile2->close();
361
362 delete geo;
363 delete par;
364 delete outputFile1;
365 delete outputFile2;
366
367 return kTRUE;
368
369}
370
371//_____________________________________________________________________________
372Bool_t AliTRDrawData::Raw2Digit(const Char_t *name1, const Char_t *name2)
373{
374
375 const Int_t kLDCHeaderLength = 8;
376 const Int_t kSubeventHeaderLength = 8;
377
378 const Int_t kNldc = 2;
379 const Char_t *name = 0;
380
381 int headerLDC[2];
382 int headerSubevent[2];
383
384 Int_t npads = 0;
385 Int_t nbyte = 0;
386 unsigned char *byte_p;
387 ifstream *inputFile = 0;
388 AliTRDdataArrayI *digits = 0;
389
390 AliTRDgeometryFull *geo = new AliTRDgeometryFull();
391 AliTRDparameter *par = new AliTRDparameter("TRDparameter"
392 ,"TRD parameter class");
393
394 // Create the digits manager
395 if (fDigitsManager) {
396 delete fDigitsManager;
397 }
398 fDigitsManager = new AliTRDdigitsManager();
399 fDigitsManager->SetDebug(fDebug);
400 fDigitsManager->CreateArrays();
401
402 for (Int_t ldc = 0; ldc < kNldc; ldc++) {
403
404 if (ldc == 0) {
405 name = name1;
406 }
407 else if (ldc == 1) {
408 name = name2;
409 }
410 if (fDebug) {
411 Info("Raw2Digit","Open the LDC input file %s",name);
412 }
413 inputFile = new ifstream(name, ios::in | ios::binary);
414
415 // Read the LDC header
416 byte_p = (unsigned char *) headerLDC;
417 inputFile->read(byte_p,kLDCHeaderLength);
418
419 if (fDebug > 1) {
420 Info("Raw2Digit","LDC header no. %d:",ldc);
421 Info("Raw2Digit","\tflag = %d",*byte_p++);
422 Info("Raw2Digit","\tldc no = %d",*byte_p++);
423 Info("Raw2Digit","\tndet = %d",*byte_p++);
424 Info("Raw2Digit","\tempty = %d",*byte_p++);
425 Info("Raw2Digit","\tempty = %d",*byte_p++);
426 Info("Raw2Digit","\tempty = %d",*byte_p++);
427 Info("Raw2Digit","\tempty = %d",*byte_p++);
428 Info("Raw2Digit","\tempty = %d",*byte_p++);
429 }
430
431 // Loop through the subevents
432 byte_p = (unsigned char *) headerSubevent;
433 while (inputFile->read(byte_p,kSubeventHeaderLength)) {
434
435 Int_t flag = *byte_p++;
436 Int_t detl = *byte_p++;
437 Int_t deth = *byte_p++;
438 Int_t det = detl + (deth << 8);
439 Int_t nbytel = *byte_p++;
440 Int_t nbyteh = *byte_p++;
441 nbyte = nbytel + (nbyteh << 8);
442 Int_t npadsl = *byte_p++;
443 Int_t npadsh = *byte_p++;
444 npads = npadsl + (npadsh << 8);
445 if (fDebug > 2) {
446 Info("Raw2Digit","Subevent header:");
447 Info("Raw2Digit","\tflag = %d",flag);
448 Info("Raw2Digit","\tdet = %d",det);
449 Info("Raw2Digit","\tnbyte = %d",nbyte);
450 Info("Raw2Digit","\tnpads = %d",npads);
451 Info("Raw2Digit","\tempty = %d",*byte_p++);
452 }
453
454 // Create the data buffer
455 Int_t cham = geo->GetChamber(det);
456 Int_t plan = geo->GetPlane(det);
457 Int_t sect = geo->GetSector(det);
458 Int_t rowMax = par->GetRowMax(plan,cham,sect);
459 Int_t colMax = par->GetColMax(plan);
460 Int_t timeMax = par->GetTimeMax();
461 Int_t bufferMax = rowMax*colMax*timeMax;
462 int *buffer = new int[bufferMax];
463 byte_p = (unsigned char *) buffer;
464 memset(buffer,0,bufferMax*sizeof(int));
465
466 // Add a container for the digits of this detector
467 digits = fDigitsManager->GetDigits(det);
468 // Allocate memory space for the digits buffer
469 if (digits->GetNtime() == 0) {
470 digits->Allocate(rowMax,colMax,timeMax);
471 }
472
473 // Read the data
474 inputFile->read(byte_p,nbyte);
475
476 Int_t time;
477 Int_t nzero;
478 Int_t data;
479 Int_t low;
480 Int_t high;
481 Int_t signal;
482
483 // Decompress the data
484 while (nbyte > 0) {
485
486 // The pad row number
487 Int_t row = (*byte_p++) - 1;
488 // The pad column number
489 Int_t col = (*byte_p++) - 1;
490 nbyte -= 2;
491
492 time = nzero = 0;
493
494 while ((time < timeMax) &&
495 (nbyte > 0)) {
496
497 data = *byte_p++;
498 nbyte--;
499
500 if (data) {
501 if (!nzero) {
502 // signal for given timebim
503 low = *byte_p++;
504 high = data & 127;
505 signal = low + (high << 8);
506 if ((row < 0) || (col < 0) || (time < 0) ||
507 (row >= rowMax) || (col >= colMax) || (time >= timeMax)) {
508 Error("Raw2Digit"
509 ,"row=%d(%d) col=%d(%d) time=%d(%d)"
510 ,row,rowMax,col,colMax,time,timeMax);
511 }
512 else {
513 digits->SetDataUnchecked(row,col,time,signal);
514 }
515 nbyte--;
516 time++;
517 }
518 else {
519 time += data + 1;
520 nzero = 0;
521 }
522 }
523 else {
524 if (!nzero) {
525 nzero = 1;
526 }
527 else {
528 time++;
529 nzero = 0;
530 }
531 }
532
533 }
534
535 }
536
537 digits->Compress(1,0);
538
539 delete buffer;
540
541 byte_p = (unsigned char *) headerSubevent;
542
543 }
544
545 inputFile->close();
546 delete inputFile;
547 inputFile = 0;
548
549 }
550
551 delete geo;
552 delete par;
553
554 return kTRUE;
555
556}