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