ITS/AliITSDDLRawData.cxx

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