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