ITS/AliITSDDLRawData.cxx

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