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