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