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