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