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