No ios::binary on Alpha with cxx
[u/mrichter/AliRoot.git] / ITS / AliITSDDLRawData.cxx
CommitLineData
2e9f335b 1/**************************************************************************
2 * Copyright(c) 1998-2003, 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 **************************************************************************/
30c1018e 15/* $Id$ */
a79660fb 16
17//This class contains all the necessary methods to create the Raw Data
18//files (slides) for the ITS data challenges for:
19//SPD
20//SDD
21//SSD
2e9f335b 22
23#include <stdlib.h>
0f0615a3 24#include "Riostream.h"
2e9f335b 25#include <TClonesArray.h>
26#include <TTree.h>
0f0615a3 27#include "TMath.h"
2e9f335b 28#include <AliITS.h>
29#include <AliITSgeom.h>
30#include <AliITSdigit.h>
31#include "AliITSDDLRawData.h"
32
33ClassImp(AliITSDDLRawData)
34
35////////////////////////////////////////////////////////////////////////////////////////
36AliITSDDLRawData::AliITSDDLRawData(){
a79660fb 37 //Default constructor
2e9f335b 38 fIndex=-1;
39 fHalfStaveModule=-1;
40}
41
42////////////////////////////////////////////////////////////////////////////////////////
43
44AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source){
a79660fb 45 //Copy Constructor
2e9f335b 46 this->fIndex=source.fIndex;
47 this->fHalfStaveModule=source.fHalfStaveModule;
48 return;
49}
50
51////////////////////////////////////////////////////////////////////////////////////////
52
53AliITSDDLRawData& AliITSDDLRawData::operator=(const AliITSDDLRawData &source){
54 //Assigment operator
55 this->fIndex=source.fIndex;
56 this->fHalfStaveModule=source.fHalfStaveModule;
57 return *this;
58}
59
60////////////////////////////////////////////////////////////////////////////////////////
61//STRIP
62//
63
64void AliITSDDLRawData::GetDigitsSSD(TClonesArray *ITSdigits,Int_t mod, ULong_t *buf){
a79660fb 65 //This method packs the SSD digits in a proper 32 bits structure
2e9f335b 66 Int_t ix;
67 Int_t iz;
68 Int_t is;
a79660fb 69 ULong_t word;
70 ULong_t baseWord;
2e9f335b 71 Int_t ndigits = ITSdigits->GetEntries();
72 AliITSdigit *digs;
73 if(ndigits){
74 for (Int_t digit=0;digit<ndigits;digit++) {
75 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
76 iz=digs->fCoord1; // If iz==0, N side and if iz=1 P side
77 ix=digs->fCoord2; // Strip Numbar
78 is=digs->fSignal; // ADC Signal
79 // cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
a79660fb 80 baseWord=0;
81 word=is-1;
82 PackWord(baseWord,word,0,9);//ADC data
83 word=ix;
84 PackWord(baseWord,word,10,19);//Strip Number
85 word=iz;
86 PackWord(baseWord,word,20,20);//ADC Channel ID (N or P side)
87 word=mod;
88 PackWord(baseWord,word,21,31);//ADC module ID
2e9f335b 89 fIndex++;
a79660fb 90 buf[fIndex]=baseWord;
2e9f335b 91 }//end for
92 }//end if
93 return;
94}//end GetDigitsSSD
95
96////////////////////////////////////////////////////////////////////////////////////////
97//Silicon Drift Detector
98//
99
100void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod, ULong_t *buf){
a79660fb 101 //This method packs the SSD digits in a proper 32 bits structure
2e9f335b 102 Int_t ix;
103 Int_t iz;
104 Int_t is;
a79660fb 105 ULong_t word;
106 ULong_t baseWord;
2e9f335b 107 Int_t ndigits = ITSdigits->GetEntries();
108 AliITSdigit *digs;
109 if(ndigits){
110 //cout<<"Mudule "<<mod<<" number of digits "<<ndigits<<endl;
111 for (Int_t digit=0;digit<ndigits;digit++) {
112 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
113 iz=digs->fCoord1; // Anode
114 ix=digs->fCoord2; // Time
115 is=digs->fSignal; // ADC Signal
116 // cout<<"Amplitude value:"<<is<<" Time Bucket:"<<ix<<" Anode:"<<iz<<endl;
117 if (is>255){cout<<"WARNING (!) bits words is needed)!!!\n";}
a79660fb 118 baseWord=0;
2e9f335b 119 /*
120 //10 bits words for amplitude value
a79660fb 121 word=is;
122 PackWord(baseWord,word,0,9);//ADC data
123 word=ix;
124 PackWord(baseWord,word,10,17);//Time bucket
125 word=iz;
126 PackWord(baseWord,word,18,26);//Anode Number
127 word=mod;
128 PackWord(baseWord,word,27,31);//Module number
2e9f335b 129 */
130
131 //8bits words for amplitude value
a79660fb 132 word=is;
133 PackWord(baseWord,word,0,7);//ADC data
134 word=ix;
135 PackWord(baseWord,word,8,15);//Time bucket
136 word=iz;
137 PackWord(baseWord,word,16,24);//Anode Number
138 word=mod;
139 PackWord(baseWord,word,25,31);//Module number
2e9f335b 140
141 fIndex++;
a79660fb 142 buf[fIndex]=baseWord;
2e9f335b 143 }//end for
144 }//end if
145 return;
146}//end GetDigitsSDD
147
148////////////////////////////////////////////////////////////////////////////////////////
149//PIXEL
150//
151
152void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod, ULong_t *buf){
a79660fb 153 //This method packs the SPD digits in a proper 32 strucure
2e9f335b 154 Int_t ix;
155 Int_t iz;
a79660fb 156 Int_t chipNo=0;
157 ULong_t baseWord=0;
158 ULong_t hitRow=0;
159 Int_t chipHitCount=0; //Number of Hit in the current chip
160 Int_t previousChip=-1; //Previuos chip respect to the actual aone
2e9f335b 161 Int_t ndigits = ITSdigits->GetEntries(); //number of digits in the current module
162 //cout<<" Number of digits in the current module:"<<ndigits<<" module:"<<mod<<endl;
163 AliITSdigit *digs;
164 fHalfStaveModule++; //It's a private variable used to distinguish between the firs
165 //and the second module of an Half Stave Module
166 if(ndigits){
167 //loop over digits
168 for (Int_t digit=0;digit<ndigits;digit++){
169 digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
170 /*---------------------------------------------------------------------------
171 * Each module contains 5 read out chips of 256 rows and 32 columns.
172 * So, the cell number in Z direction varies from 1 to 160. Therefore,
173 * to get the chip address (0 to 4), we need to divide column number by 32.
174 * ---------------------------------------------------------------------*/
175 iz=digs->fCoord1; // Cell number in Z direction
176 ix=digs->fCoord2; // Cell number in X direction
a79660fb 177 chipNo=iz/32;
178 hitRow=iz-chipNo*32;
2e9f335b 179 if(fHalfStaveModule){
a79660fb 180 chipNo+=5;
2e9f335b 181 fHalfStaveModule=-1;
182 }//end if
a79660fb 183 //cout<<"Chip number of the current digit:"<<chipNo<<" Row:"<<hitRow<<" Column:"<<ix<<endl;
184 if(previousChip==-1){
2e9f335b 185 //loop over chip without digits
186 //Even if there aren't digits for a given chip
187 //the chip header and the chip trailer are stored
188 for(Int_t i=0;i<(iz/32);i++){
a79660fb 189 if(chipNo>4)
190 WriteChipHeader(i+5,(mod/2),baseWord);
2e9f335b 191 else
a79660fb 192 WriteChipHeader(i,(mod/2),baseWord);
193 WriteChipTrailer(buf,chipHitCount,baseWord);
2e9f335b 194 }//end for
a79660fb 195 previousChip=chipNo;
196 WriteChipHeader(chipNo,(mod/2),baseWord);
197 chipHitCount++;
198 WriteHit(buf,ix,hitRow,baseWord);
2e9f335b 199 }//end if
200 else{
a79660fb 201 chipHitCount++;
202 if(previousChip!=chipNo){
203 WriteChipTrailer(buf,chipHitCount-1,baseWord);
204 for(Int_t i=previousChip+1;i<chipNo;i++){
205 WriteChipHeader(i,(mod/2),baseWord);
206 WriteChipTrailer(buf,0,baseWord);
2e9f335b 207 }//end for
a79660fb 208 WriteChipHeader(chipNo,(mod/2),baseWord);
209 previousChip=chipNo;
2e9f335b 210 }//end if
a79660fb 211 WriteHit(buf,ix,hitRow,baseWord);
2e9f335b 212 }//end else
213 }//end for
214 //Even if there aren't digits for a given chip
215 //the chip header and the chip trailer are stored
a79660fb 216 Int_t end=4;
217 if(chipNo>4)end+=5;
218 WriteChipTrailer(buf,chipHitCount,baseWord);
219 for(Int_t i=chipNo+1;i<=end;i++){
220 WriteChipHeader(i,(mod/2),baseWord);
221 WriteChipTrailer(buf,0,baseWord);
2e9f335b 222 }//end for
223 }//end if
224 else{
225 //In this module there aren't digits but
226 //the chip header and chip trailer are store anyway
227 if(fHalfStaveModule){
a79660fb 228 chipNo=5;
2e9f335b 229 fHalfStaveModule=-1;
230 }//end if
231 for(Int_t i=0;i<5;i++){
a79660fb 232 WriteChipHeader(chipNo+i,(mod/2),baseWord);
233 WriteChipTrailer(buf,chipHitCount,baseWord);
2e9f335b 234 }//end for
235 }//end else
236 return;
237}//end GetDigitsSPD
238
239////////////////////////////////////////////////////////////////////////////////////////////////////////////////
240
241void AliITSDDLRawData::PackWord(ULong_t &BaseWord, ULong_t Word, Int_t StartBit, Int_t StopBit){
a79660fb 242 //This method packs a word into the Baseword buffer starting form the "StartBit"
243 //and tacking StopBit-StertBit+1 bits
244 ULong_t dummyWord,offSet;
245 Int_t length;
246 ULong_t sum;
2e9f335b 247 //The BaseWord is being filled with 1 from StartBit to StopBit
a79660fb 248 length=StopBit-StartBit+1;
249 sum=(ULong_t)TMath::Power(2,length)-1;
250 if(Word > sum){
2e9f335b 251 cout<<"WARNING::Word to be filled is not within desired length"<<endl;
252 cout<<"Word:"<<Word<<" Start bit:"<<StartBit<<" Stop Bit:"<<StopBit<<endl;
253 exit(-1);
254 }
a79660fb 255 offSet=sum;
256 offSet<<=StartBit;
257 BaseWord=BaseWord|offSet;
2e9f335b 258 //The Word to be filled is shifted to the position StartBit
259 //and the remaining Left and Right bits are filled with 1
a79660fb 260 sum=(ULong_t)TMath::Power(2,StartBit)-1;
261 dummyWord=0xFFFFFFFF<<length;
262 dummyWord +=Word;
263 dummyWord<<=StartBit;
264 dummyWord+=sum;
265 BaseWord=BaseWord&dummyWord;
2e9f335b 266 return;
267}
268
269/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
270
271void AliITSDDLRawData::UnpackWord(ULong_t PackedWord, Int_t StartBit, Int_t StopBit, ULong_t &Word){
a79660fb 272 //This method unpacks a words of StopBit-StertBit+1 bits starting from "StopBits"
273 ULong_t offSet;
274 Int_t length;
275 length=StopBit-StartBit+1;
276 offSet=(ULong_t)TMath::Power(2,length)-1;
277 offSet<<=StartBit;
278 Word=PackedWord&offSet;
2e9f335b 279 Word>>=StartBit;
280 return;
281}
282
283/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
284
285Int_t AliITSDDLRawData::RawDataSPD(AliITS *ITS,TTree *TD ,Int_t LDCsNumber){
a79660fb 286 //This method creates the Raw data files for SPD detectors
2e9f335b 287 //Silicon Pixel Detector
a79660fb 288 const Int_t kDDLsNumber=20; // Number of DDL in SPD
289 const Int_t kModulesPerDDL=12; // Number of modules in each DDL
2e9f335b 290 //Row ==> DDLs
291 //Column ==> Modules
a79660fb 292 Int_t mapSPD[kDDLsNumber][kModulesPerDDL]={{ 0, 1, 4, 5, 80, 81, 84, 85, 88, 89, 92, 93},
2e9f335b 293 { 2, 3, 6, 7, 82, 83, 86, 87, 90, 91, 94, 95},
294 { 8, 9,12,13, 96, 97,100,101,104,105,108,109},
295 {10,11,14,15, 98, 99,102,103,106,107,110,111},
296 {16,17,20,21,112,113,116,117,120,121,124,125},
297 {18,19,22,23,114,115,118,119,122,123,126,127},
298 {24,25,28,29,128,129,132,133,136,137,140,141},
299 {26,27,30,31,130,131,134,135,138,139,142,143},
300 {32,33,36,37,144,145,148,149,152,153,156,157},
301 {34,35,38,39,146,147,150,151,154,155,158,159},
302 {40,41,44,45,160,161,164,165,168,169,172,173},
303 {42,43,46,47,162,163,166,167,170,171,174,175},
304 {48,47,50,51,176,177,180,181,184,185,188,189},
305 {50,51,54,55,178,179,182,183,186,187,190,191},
306 {56,57,60,61,192,193,196,197,200,201,204,205},
307 {58,59,62,63,194,195,198,199,202,203,206,207},
308 {64,65,68,69,208,209,212,213,216,217,220,221},
309 {66,67,70,71,210,211,214,215,218,219,222,223},
310 {72,73,76,77,224,225,228,229,232,233,236,237},
311 {74,75,78,79,226,227,230,231,234,235,238,239}};
a79660fb 312 Int_t ddlsPerFile=kDDLsNumber/LDCsNumber;
313 if(kDDLsNumber%LDCsNumber)ddlsPerFile++;
314 cout<<"Number of DDL per File: "<<ddlsPerFile<<endl;
2e9f335b 315 Int_t subd=0;
a79660fb 316 Int_t countDDL=0;
317 Int_t sliceNumber=1;
318 const Int_t kSize=21000; //256*32*5=40960 max number of digits per module
319 ULong_t buf[kSize]; //One buffer cell can contain 2 digits
2e9f335b 320 fIndex=-1;
a79660fb 321 TClonesArray *digitsInITS = ITS->DigitsAddress(subd);
2e9f335b 322
323 Int_t nbytes = 0;
324 char fileName[15];
325
a79660fb 326 ULong_t miniHeaderPosition=0; //variable used to store the position of the Mini Header inside a file
2e9f335b 327 ofstream outfile; // logical name of the output file
a79660fb 328 Int_t flag=0; // 0==> Uncompressed data 1==>Compressed Data
329 Int_t detector=1; // 1==>ITS (Pixel) 2==>ITS (Drift) 3==>ITS (Strip) 0==>TPC ......
330 ULong_t size=0; // size of the data block that follows the mini header
331 Int_t magicWord=0x123456; // Magic word used to distinguish between data and garbage
332 sprintf(fileName,"SPDslice%d",sliceNumber); //The name of the output file. There are as many slides as the number of LDC
30c1018e 333#ifndef __DECCXX
2e9f335b 334 outfile.open(fileName,ios::binary);
30c1018e 335#else
336 outfile.open(fileName);
337#endif
a79660fb 338 ULong_t miniHeader[3];
339 Int_t miniHeaderSize=sizeof(ULong_t)*3;
340 Int_t version=1; //version of the mini header
2e9f335b 341 //loop over DDLs
a79660fb 342 for(Int_t i=0;i<kDDLsNumber;i++){
343 countDDL++;
2e9f335b 344 //write Dummy MINI HEADER
a79660fb 345 miniHeader[0]=size;
346 PackWord(miniHeader[1],magicWord,8,31);
347 PackWord(miniHeader[1],detector,0,7);
348 PackWord(miniHeader[2],i,16,31);
349 PackWord(miniHeader[2],flag,8,15);
350 PackWord(miniHeader[2],version,0,7);
351 miniHeaderPosition=outfile.tellp();
352 outfile.write((char*)(miniHeader),miniHeaderSize);
2e9f335b 353 //Loops over Modules of a particular DDL
a79660fb 354 for (Int_t mod=0; mod<kModulesPerDDL; mod++){
2e9f335b 355 ITS->ResetDigits();
a79660fb 356 nbytes += TD->GetEvent(mapSPD[i][mod]);
2e9f335b 357 //For each Module, buf contains the array of data words in Binary format
358 //fIndex gives the number of 32 bits words in the buffer for each module
a79660fb 359 GetDigitsSPD(digitsInITS,mapSPD[i][mod],buf);
2e9f335b 360 outfile.write((char *)buf,((fIndex+1)*sizeof(ULong_t)));
361 for(Int_t i=0;i<(fIndex+1);i++){
362 buf[i]=0;
363 }//end for
364 fIndex=-1;
365 }//end for
366
367 //Write REAL MINI HEADER
a79660fb 368 ULong_t currentFilePosition=outfile.tellp();
369 outfile.seekp(miniHeaderPosition);
370 size=currentFilePosition-miniHeaderPosition-miniHeaderSize;
2e9f335b 371
a79660fb 372 outfile.write((char*)(&size),sizeof(ULong_t));
373 outfile.seekp(currentFilePosition);
374 if(countDDL==ddlsPerFile){
2e9f335b 375 outfile.close();
a79660fb 376 sliceNumber++;
377 sprintf(fileName,"SPDslice%d",sliceNumber);
378 if(i!=(kDDLsNumber-1))
30c1018e 379#ifndef __DECCXX
2e9f335b 380 outfile.open(fileName,ios::binary);
30c1018e 381#else
382 outfile.open(fileName);
383#endif
a79660fb 384 countDDL=0;
2e9f335b 385 }//end if
386 }//end for
387 outfile.close();
388 return 0;
389}
390
391/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
392
393Int_t AliITSDDLRawData::RawDataSSD(AliITS *ITS,TTree *TD ,Int_t LDCsNumber){
a79660fb 394 //This method creates the Raw data files for SSD detectors
2e9f335b 395 //Strip detector
a79660fb 396 const Int_t kDDLsNumber=16; // Number of DDL in SSD
397 const Int_t kModulesPerDDL=109; // Number of modules in each DDL
2e9f335b 398 //DDL from 32 to 47 (16 DDL)
399 //Row ==> DDLs
400 //Column ==> Modules
a79660fb 401 Int_t mapSSD[kDDLsNumber][kModulesPerDDL]={
2e9f335b 402 //104
403 //DDL[32][]=
404 { 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510,
405 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532,
406 1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,
407 1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,
408 1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,
409 2098,2099,2100,2101,2102,2103,2104,2105,2106,2107,2108,2109,
410 2123,2124,2125,2126,2127,2128,2129,2130,2131,2132,2133,2134,
411 2148,2149,2150,2151,2152,2153,2154,2155,2156,2157,2158,2159,
412 2173,2174,2175,2176,2177,2178,2179,2180,2181,2182,2183,2184,-1,-1,-1,-1,-1},
413 //93
414 //DDL[33][]=
415 { 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
416 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598,
417 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620,
418 1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,
419 1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,
420 1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,
421 1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,
422 1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,
423 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,-1,-1,-1,-1},
424 //103
425 //DDL[34][]=
426 { 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642,
427 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664,
428 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686,
429 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708,
430 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730,
431 1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,
432 1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,
433 1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,
434 1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,-1,-1,-1,-1,-1,-1},
435 //104
436 //DDL[35][]=
437 { 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
438 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774,
439 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796,
440 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818,
441 1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,
442 1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,
443 1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,
444 1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,
445 1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,-1,-1,-1,-1,-1},
446 //104
447 //DDL[36[]=
448 { 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840,
449 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862,
450 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884,
451 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906,
452 1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,
453 1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,
454 1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1682,1684,
455 1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,
456 1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,-1,-1,-1,-1,-1},
457 //104
458 //DDL[37][]=
459 { 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928,
460 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950,
461 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972,
462 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994,
463 1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,
464 1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,
465 1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,
466 1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,
467 1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,-1,-1,-1,-1,-1},
468 //103
469 //DDL[38][]=
470 {1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,
471 1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,
472 1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,
473 1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,
474 1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,
475 1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,
476 1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,
477 1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,
478 1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,-1,-1,-1,-1,-1,-1},
479 //104
480 //DDL[39][]=
481 {1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,
482 1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,
483 1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,
484 1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,
485 1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,
486 1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,
487 2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,
488 2048,2049,2050,2051,2052,2053,2054,2055,2056,2057,2058,2059,
489 2073,2074,2075,2076,2077,2078,2079,2080,2081,2082,2083,2084,-1,-1,-1,-1,-1},
490 //109
491 //DDL[40][]=
492 { 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521,
493 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543,
494 1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,
495 1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,
496 1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,
497 2110,2111,2112,2113,2114,2115,2116,2117,2118,2119,2120,2121,2122,
498 2135,2136,2137,2138,2139,2140,2141,2142,2143,2144,2145,2146,2147,
499 2160,2161,2162,2163,2164,2165,2166,2167,2168,2169,2170,2171,2172,
500 2185,2186,2187,2188,2189,2190,2191,2192,2193,2194,2195,2196,2197},
501 //109
502 //DDL[41][]=
503 { 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565,
504 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587,
505 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609,
506 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631,
507 1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,
508 1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,
509 1335,1336,1337,1338,1339,1340,1341,1342,1443,1344,1345,1346,1347,
510 1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,
511 1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397},
512 //107
513 //DDL[42][]=
514 { 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653,
515 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675,
516 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697,
517 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719,
518 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741,
519 1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,
520 1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,
521 1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,
522 1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,-1,-1},
523 //109
524 //DDL[43][]=
525 { 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763,
526 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785,
527 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807,
528 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829,
529 1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,
530 1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,
531 1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,
532 1585,1586,1587,1588,1589,1590,1591,1592,1593,1584,1595,1596,1597,
533 1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622},
534 //109
535 //DDL[44][]=
536 { 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851,
537 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873,
538 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895,
539 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917,
540 1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,
541 1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,
542 1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,
543 1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,
544 1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747},
545 //109
546 //DDL[45][]=
547 {929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939,
548 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961,
549 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983,
550 995, 996, 997, 998, 999,1000,1001,1002,1003,1004,1005,
551 1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,
552 1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,
553 1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,
554 1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,
555 1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872},
556 //109
557 //DDL[46][]=
558 {1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,
559 1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,
560 1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,
561 1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,
562 1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,
563 1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,
564 1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,
565 1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,
566 1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972},
567 //109
568 //DDL[47][]=
569 {1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,
570 1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,
571 1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,
572 1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,
573 1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,
574 2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,
575 2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047,
576 2060,2061,2062,2063,2064,2065,2066,2067,2068,2069,2070,2071,2072,
577 2085,2086,2087,2088,2089,2090,2091,2092,2093,2094,2095,2096,2097} };
578
579
a79660fb 580 Int_t ddlsPerFile=kDDLsNumber/LDCsNumber;
581 if(20%LDCsNumber)ddlsPerFile++;
582 cout<<"Number of DDL per File: "<<ddlsPerFile<<endl;
2e9f335b 583 Int_t subd=2; //SSD
a79660fb 584 Int_t countDDL=0;
585 Int_t sliceNumber=1;
586 const Int_t kSize=1536;//768*2 Number of stripe * number of sides(N and P)
587 ULong_t buf[kSize];
2e9f335b 588 fIndex=-1;
589 Int_t nbytes = 0;
a79660fb 590 TClonesArray *digitsInITS = ITS->DigitsAddress(subd);
2e9f335b 591 char fileName[15];
592
a79660fb 593 ULong_t miniHeaderPosition=0; //variable used to store the position of the Mini Header inside the file
2e9f335b 594 ofstream outfile; // logical name of the output file
a79660fb 595 Int_t flag=0; // 0==> Uncompressed data 1==>Compressed Data
596 Int_t detector=3; // 1==>ITS (Pixel) 2==>ITS (Drift) 3==>ITS (Strip) 0==>TPC ......
597 ULong_t size=0; // size of the data block that follows the mini header
598 Int_t magicWord=0x123456; // Magic word used to distinguish between data and garbage
599 sprintf(fileName,"SSDslice%d",sliceNumber); //The name of the output file. There are as many slides as the number of LDC
30c1018e 600#ifndef __DECCXX
2e9f335b 601 outfile.open(fileName,ios::binary);
30c1018e 602#else
603 outfile.open(fileName);
604#endif
a79660fb 605 ULong_t miniHeader[3];
606 Int_t miniHeaderSize=sizeof(ULong_t)*3;
607 Int_t version=1; //version of the mini header
2e9f335b 608 //loop over DDLs
609
a79660fb 610 for(Int_t i=0;i<kDDLsNumber;i++){
611 countDDL++;
2e9f335b 612 //write Dummy MINI HEADER
a79660fb 613 miniHeader[0]=size;
614 PackWord(miniHeader[1],magicWord,8,31);
615 PackWord(miniHeader[1],detector,0,7);
616 PackWord(miniHeader[2],i,16,31);
617 PackWord(miniHeader[2],flag,8,15);
618 PackWord(miniHeader[2],version,0,7);
619 miniHeaderPosition=outfile.tellp();
620 outfile.write((char*)(miniHeader),miniHeaderSize);
2e9f335b 621
622 //Loops over Modules of a particular DDL
a79660fb 623 for (Int_t mod=0; mod<kModulesPerDDL; mod++){
624 if(mapSSD[i][mod]!=-1){
2e9f335b 625 ITS->ResetDigits();
a79660fb 626 nbytes += TD->GetEvent(mapSSD[i][mod]);
2e9f335b 627 //For each Module, buf contains the array of data words in Binary format
628 //fIndex gives the number of 32 bits words in the buffer for each module
a79660fb 629 GetDigitsSSD(digitsInITS,mod,buf);
2e9f335b 630 outfile.write((char *)buf,((fIndex+1)*sizeof(ULong_t)));
631 for(Int_t i=0;i<(fIndex+1);i++){
632 buf[i]=0;
633 }//end for
634 fIndex=-1;
635 }//end if
636 }//end for
637 //Write REAL MINI HEADER
a79660fb 638 ULong_t currentFilePosition=outfile.tellp();
639 outfile.seekp(miniHeaderPosition);
640 size=currentFilePosition-miniHeaderPosition-miniHeaderSize;
2e9f335b 641
a79660fb 642 outfile.write((char*)(&size),sizeof(ULong_t));
643 outfile.seekp(currentFilePosition);
644 if(countDDL==ddlsPerFile){
2e9f335b 645 outfile.close();
a79660fb 646 sliceNumber++;
647 sprintf(fileName,"SSDslice%d",sliceNumber);
648 if(i!=(kDDLsNumber-1))
30c1018e 649#ifndef __DECCXX
2e9f335b 650 outfile.open(fileName,ios::binary);
30c1018e 651#else
652 outfile.open(fileName);
653#endif
a79660fb 654 countDDL=0;
2e9f335b 655 }//end if
656 }//end for
657 outfile.close();
658 return 0;
659}
660
661/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
662
663Int_t AliITSDDLRawData::RawDataSDD(AliITS *ITS,TTree *TD ,Int_t LDCsNumber){
a79660fb 664 //This method creates the Raw data files for SDD detectors
665 //Silicon Drift detector
666 const Int_t kDDLsNumber=12; // Number of DDL in SPD
667 const Int_t kModulesPerDDL=22; // Number of modules in each DDL
2e9f335b 668 //Row ==> DDLs
669 //Column ==> Modules
a79660fb 670 Int_t mapSDD[kDDLsNumber][kModulesPerDDL]= {{240,241,242,246,247,248,252,253,254,258,259,260,264,265,266,270,271,272,276,277,278,-1},
2e9f335b 671 {243,244,245,249,250,251,255,256,257,261,262,263,267,268,269,273,274,275,279,280,281,-1},
672 {282,283,284,288,289,290,294,295,296,300,301,302,306,307,308,312,313,314,318,319,320,-1},
673 {285,286,287,291,292,293,297,298,299,303,304,305,309,310,311,315,316,317,321,322,323,-1},
674 {324,325,326,327,332,333,334,335,340,341,342,343,348,349,350,351,356,357,358,359,364,365},
675 {328,329,330,331,336,337,338,339,344,345,346,347,352,353,354,355,360,361,362,363,368,369},
676 {366,367,372,373,374,375,380,381,382,383,388,389,390,391,396,397,398,399,404,405,406,407},
677 {370,371,376,377,378,379,384,385,386,387,392,393,394,395,400,401,402,403,408,409,410,411},
678 {412,413,414,415,420,421,422,423,428,429,430,431,436,436,438,439,444,445,446,447,452,453},
679 {416,417,418,419,424,425,426,427,432,433,434,435,440,441,442,443,448,449,450,451,456,457},
680 {454,455,460,461,462,463,468,469,470,471,476,477,478,479,484,485,486,487,492,493,494,495},
681 {458,459,464,465,466,467,472,473,474,475,480,481,482,483,488,489,490,491,496,497,498,499}};
682
a79660fb 683 Int_t ddlsPerFile=kDDLsNumber/LDCsNumber;
684 if(kDDLsNumber%LDCsNumber)ddlsPerFile++;
685 cout<<"Number of DDL per File: "<<ddlsPerFile<<endl;
2e9f335b 686 Int_t subd=1;
a79660fb 687 Int_t countDDL=0;
688 Int_t sliceNumber=1;
689 const Int_t kSize=131072; //256*512
690 ULong_t buf[kSize];
2e9f335b 691 fIndex=-1;
692 Int_t nbytes = 0;
a79660fb 693 TClonesArray *digitsInITS = ITS->DigitsAddress(subd);
2e9f335b 694 char fileName[15];
695
a79660fb 696 ULong_t miniHeaderPosition=0; // variable used to store the position of the Mini Header inside a file
2e9f335b 697 ofstream outfile; // logical name of the output file
a79660fb 698 Int_t flag=0; // 0==> Uncompressed data 1==>Compressed Data
699 Int_t detector=2; // 1==>ITS (Pixel) 2==>ITS (Drift) 3==>ITS (Strip) 0==>TPC ......
700 ULong_t size=0; // size of the data block that follows the mini header
701 Int_t magicWord=0x123456; // Magic word used to distinguish between data and garbage
702 sprintf(fileName,"SDDslice%d",sliceNumber); //The name of the output file. There are as many slides as the number of LDC
30c1018e 703#ifndef __DECCXX
2e9f335b 704 outfile.open(fileName,ios::binary);
30c1018e 705#else
706 outfile.open(fileName);
707#endif
a79660fb 708 ULong_t miniHeader[3];
709 Int_t miniHeaderSize=sizeof(ULong_t)*3;
710 Int_t version=1; //version of the mini header
2e9f335b 711 //loop over DDLs
a79660fb 712 for(Int_t i=0;i<kDDLsNumber;i++){
713 countDDL++;
2e9f335b 714 //write Dummy MINI HEADER
a79660fb 715 miniHeader[0]=size;
716 PackWord(miniHeader[1],magicWord,8,31);
717 PackWord(miniHeader[1],detector,0,7);
718 PackWord(miniHeader[2],i,16,31);
719 PackWord(miniHeader[2],flag,8,15);
720 PackWord(miniHeader[2],version,0,7);
721 miniHeaderPosition=outfile.tellp();
722 outfile.write((char*)(miniHeader),miniHeaderSize);
2e9f335b 723 //Loops over Modules of a particular DDL
a79660fb 724 for (Int_t mod=0; mod<kModulesPerDDL; mod++){
725 if(mapSDD[i][mod]!=-1){
2e9f335b 726 ITS->ResetDigits();
a79660fb 727 nbytes += TD->GetEvent(mapSDD[i][mod]);
2e9f335b 728 //For each Module, buf contains the array of data words in Binary format
729 //fIndex gives the number of 32 bits words in the buffer for each module
a79660fb 730 // cout<<"MODULE NUMBER:"<<mapSDD[i][mod]<<endl;
731 GetDigitsSDD(digitsInITS,mod,buf);
2e9f335b 732 outfile.write((char *)buf,((fIndex+1)*sizeof(ULong_t)));
733 for(Int_t i=0;i<(fIndex+1);i++){
734 buf[i]=0;
735 }//end for
736 fIndex=-1;
737 }//end if
738 }//end for
739
740 //Write REAL MINI HEADER
a79660fb 741 ULong_t currentFilePosition=outfile.tellp();
742 outfile.seekp(miniHeaderPosition);
743 size=currentFilePosition-miniHeaderPosition-miniHeaderSize;
2e9f335b 744
a79660fb 745 outfile.write((char*)(&size),sizeof(ULong_t));
746 outfile.seekp(currentFilePosition);
747 if(countDDL==ddlsPerFile){
2e9f335b 748 outfile.close();
a79660fb 749 sliceNumber++;
750 sprintf(fileName,"SDDslice%d",sliceNumber);
751 if(i!=(kDDLsNumber-1))
30c1018e 752#ifndef __DECCXX
2e9f335b 753 outfile.open(fileName,ios::binary);
30c1018e 754#else
755 outfile.open(fileName);
756#endif
a79660fb 757 countDDL=0;
2e9f335b 758 }//end if
759 }//end for
760 outfile.close();
761 return 0;
762}
763
764/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
765
766void AliITSDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t EventCnt,ULong_t &BaseWord){
a79660fb 767 //This method writes a chip header
2e9f335b 768 //cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<EventCnt<<endl;
769 BaseWord=0;
770 PackWord(BaseWord,ChipAddr,0,3);
771 PackWord(BaseWord,EventCnt,4,10);
772 PackWord(BaseWord,0x7,11,13);
773 PackWord(BaseWord,0x1,14,15);
774 return;
775}//end WriteChipHeader
776
777/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
778
779void AliITSDDLRawData::ReadChipHeader(Int_t &ChipAddr,Int_t &EventCnt,ULong_t BaseWord){
a79660fb 780 //This method reads a chip header
2e9f335b 781 ULong_t temp=0;
782 UnpackWord(BaseWord,0,3,temp);
783 ChipAddr=(Int_t)temp;
784 UnpackWord(BaseWord,4,10,temp);
785 EventCnt=(Int_t)temp;
786 cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<EventCnt<<endl;
787 return;
788}//end ReadChipHeader
789
790/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
791
792void AliITSDDLRawData::WriteChipTrailer(ULong_t *buf,Int_t ChipHitCount,ULong_t &BaseWord){
a79660fb 793 //This method writes a chip trailer
2e9f335b 794 //pixel fill word
795 if((ChipHitCount%2)!=0){
796 PackWord(BaseWord,0xFECD,0,15);
797 }
798 PackWord(BaseWord,ChipHitCount,16,28);
799 PackWord(BaseWord,0x0,30,31);
800 fIndex++;
801 buf[fIndex]=BaseWord;
802 BaseWord=0;
803 return;
804}//end WriteChipTrailer
805
806/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
807
808void AliITSDDLRawData::ReadChipTrailer(Int_t &ChipHitCount,ULong_t BaseWord){
a79660fb 809 //This method reads a chip trailer
2e9f335b 810 ULong_t temp=0;
811 UnpackWord(BaseWord,16,28,temp);
812 ChipHitCount=(Int_t)temp;
813 return;
814}//end ReadChipTrailer
815
816/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
817
818void AliITSDDLRawData::WriteHit(ULong_t *buf,Int_t RowAddr,Int_t HitAddr,ULong_t &BaseWord){
a79660fb 819 //This method writs an hit
2e9f335b 820 if(!BaseWord){
821 PackWord(BaseWord,HitAddr,0,4);
822 PackWord(BaseWord,RowAddr,5,12);
823 PackWord(BaseWord,2,14,15);
824 }//end if
825 else{
826 PackWord(BaseWord,HitAddr,16,20);
827 PackWord(BaseWord,RowAddr,21,28);
828 PackWord(BaseWord,2,30,31);
829 fIndex++;
830 buf[fIndex]=BaseWord;
831 BaseWord=0;
832 }//end else
833 return;
834}//end WriteHit
835
836/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
837
838void AliITSDDLRawData::TestFormat(){
a79660fb 839 //This method generates a text file containing SPD information
840 //Used for debugging
2e9f335b 841 ifstream f;
a79660fb 842 Int_t ldcsNumber=2;
2e9f335b 843 ofstream ftxt("File2.txt");
a79660fb 844 ULong_t size=0;
2e9f335b 845 char filename[15];
a79660fb 846 ULong_t ddlsNumber=0;
847 ULong_t miniHeader[3];
848 Int_t miniHeaderSize=sizeof(ULong_t)*3;
849 for(Int_t i=1;i<=ldcsNumber;i++){
2e9f335b 850 sprintf(filename,"SPDslice%d",i);
30c1018e 851#ifndef __DECCXX
2e9f335b 852 f.open(filename,ios::binary|ios::in);
30c1018e 853#else
854 f.open(filename,ios::in);
855#endif
2e9f335b 856 if(!f){exit(1);}
857 //loop over the DDL block
858 //here the Mini Header is read
a79660fb 859 while( f.read((char*)(miniHeader),miniHeaderSize)){
860 //cout<<"Block Size: "<<size<<endl;
861 size=miniHeader[0];
862 UnpackWord(miniHeader[2],16,31,ddlsNumber);
863 ftxt<<"DDL NUMBER:"<<ddlsNumber<<endl;
864 ULong_t word=0;
865 ULong_t code=0;
866 ULong_t decoded1,decoded2=0;
867 for(ULong_t j=0;j<(size/4);j++){
868 f.read((char*)(&word),sizeof(word)); //32 bits word
869 code=0;
870 UnpackWord(word,14,15,code);
871 DecodeWord(code,word,0,decoded1,decoded2);
872 switch (code){
2e9f335b 873 case 0://trailer
a79660fb 874 ftxt<<"Number of Hit:"<<decoded1<<endl;
2e9f335b 875 break;
876 case 1://header
a79660fb 877 ftxt<<"Half Stave Number:"<<decoded1<<" Chip Number:"<<decoded2<<endl;
2e9f335b 878 break;
879 case 2://hit
a79660fb 880 ftxt<<"Row:"<<decoded1<<" Column:"<<decoded2<<endl;
2e9f335b 881 break;
882 case 3://fill word
883 break;
884 }//end switch
a79660fb 885 code=0;
886 UnpackWord(word,30,31,code);
887 DecodeWord(code,word,1,decoded1,decoded2);
888 switch (code){
2e9f335b 889 case 0://trailer
a79660fb 890 ftxt<<"Number of Hit:"<<decoded1<<endl;
2e9f335b 891 break;
892 case 1://header
a79660fb 893 ftxt<<"Half Stave Number:"<<decoded1<<" Chip Number:"<<decoded2<<endl;
2e9f335b 894 break;
895 case 2://hit
a79660fb 896 ftxt<<"Row:"<<decoded1<<" Column:"<<decoded2<<endl;
2e9f335b 897 break;
898 case 3://fill word
899 break;
900 }//end switch
901 }//end for
902 }//end while
cd43b5e1 903 f.clear();
2e9f335b 904 f.close();
905 }//end for
906 ftxt.close();
907 return;
908}
909
910void AliITSDDLRawData::DecodeWord(ULong_t Code,ULong_t BaseWord,Int_t FirstHalf,ULong_t &Decoded1,ULong_t &Decoded2){
911 //FirstHalf=0 ==>bits from 0 to 15
912 //FirstHalf=1 ==>bits from 16 to 31
913 if(!FirstHalf){
914 switch (Code){
915 case 0://trailer
916 UnpackWord(BaseWord,0,12,Decoded1);
917 break;
918 case 1://header
919 UnpackWord(BaseWord,4,10,Decoded1);
920 UnpackWord(BaseWord,0,3,Decoded2);
921 break;
922 case 2://hit
923 UnpackWord(BaseWord,5,12,Decoded1);
924 UnpackWord(BaseWord,0,4,Decoded2);
925 break;//fill word
926 case 3:
927 UnpackWord(BaseWord,0,13,Decoded1);
928 break;
929 }//end switch
930 }
931 else{
932 switch (Code){
933 case 0://trailer
934 UnpackWord(BaseWord,16,28,Decoded1);
935 break;
936 case 1://header
937 UnpackWord(BaseWord,20,26,Decoded1);
938 UnpackWord(BaseWord,16,19,Decoded2);
939 break;
940 case 2://hit
941 UnpackWord(BaseWord,21,28,Decoded1);
942 UnpackWord(BaseWord,16,20,Decoded2);
943 break;
944 case 3://fill word
945 UnpackWord(BaseWord,16,29,Decoded1);
946 break;
947 }//end switch
948 }
949 return;
950}