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