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