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