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