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