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