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