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 <TClonesArray.h>
  27 #include <TTree.h>
  28 #include "AliITSdigit.h"
  29 #include "AliITSDDLRawData.h"
  30 #include "AliRawDataHeader.h"
  31 #include "AliITSRawStreamSPD.h"
  32 #include "AliITSRawStreamSDD.h"
  33 #include "AliITSRawStreamSSD.h"
  34 #include "AliBitPacking.h"
  35 #include "AliDAQ.h"
  36 #include "AliFstream.h"
  37
  38 ClassImp(AliITSDDLRawData)
  39
  40 ////////////////////////////////////////////////////////////////////////////////////////
  41 AliITSDDLRawData::AliITSDDLRawData():
  42 fVerbose(0),
  43 fIndex(-1),
  44 fHalfStaveModule(-1){
  45   //Default constructor
  46
  47 }
  48
  49 ////////////////////////////////////////////////////////////////////////////////////////
  50
  51 AliITSDDLRawData::AliITSDDLRawData(const AliITSDDLRawData &source) :
  52     TObject(source),
  53 fVerbose(source.fVerbose),
  54 fIndex(source.fIndex),
  55 fHalfStaveModule(source.fHalfStaveModule){
  56   //Copy Constructor
  57 }
  58
  59 ////////////////////////////////////////////////////////////////////////////////////////
  60
  61 AliITSDDLRawData& AliITSDDLRawData::operator=(const AliITSDDLRawData &source){
  62   //Assigment operator
  63   this->fIndex=source.fIndex;
  64   this->fHalfStaveModule=source.fHalfStaveModule;
  65   this->fVerbose=source.fVerbose;
  66   return *this;
  67 }
  68
  69 ////////////////////////////////////////////////////////////////////////////////////////
  70 //STRIP
  71 //
  72
  73 void AliITSDDLRawData::GetDigitsSSD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){
  74   //This method packs the SSD digits in a proper 32 bits structure
  75   Int_t ix;
  76   Int_t iz;
  77   Int_t is;
  78   UInt_t word;
  79   UInt_t baseWord;
  80   Int_t ndigits = ITSdigits->GetEntries();
  81   AliITSdigit *digs;
  82   ofstream ftxt;
  83   if(ndigits){
  84     if (fVerbose==2){
  85       ftxt.open("SSDdigits.txt",ios::app);
  86     }
  87     for (Int_t digit=0;digit<ndigits;digit++) {
  88       digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
  89       iz=digs->GetCoord1();  // If iz==0, N side and if iz=1 P side
  90       ix=digs->GetCoord2();  // Strip Numbar
  91       is=digs->GetCompressedSignal();  // ADC Signal
  92       // cout<<" Module:"<<mod-500<<" N/P side:"<<iz<<" Strip Number:"<<ix<<" Amplidute:"<<is-1<<endl;
  93       if (fVerbose==2)
  94         ftxt<<"DDL:"<<ddl<<" Mod: "<<modR<<" N/P: "<<iz<<" Strip: "<<ix<<" Value: "<<is-1<<endl;
  95       baseWord=0;
  96       word=is-1;
  97       AliBitPacking::PackWord(word,baseWord,0,9);//ADC data
  98       word=ix;
  99       AliBitPacking::PackWord(word,baseWord,10,19);//Strip Number
 100       word=iz;
 101       AliBitPacking::PackWord(word,baseWord,20,20);//ADC Channel ID (N or P side)
 102       word=mod;
 103       AliBitPacking::PackWord(word,baseWord,21,31);//ADC module ID
 104       fIndex++;
 105       buf[fIndex]=baseWord;
 106     }//end for
 107   }//end if
 108   if (fVerbose==2)
 109     ftxt.close();
 110   return;
 111 }//end GetDigitsSSD
 112
 113 ////////////////////////////////////////////////////////////////////////////////////////
 114 //Silicon Drift Detector
 115 //
 116
 117 void AliITSDDLRawData::GetDigitsSDD(TClonesArray *ITSdigits,Int_t mod,Int_t modR,Int_t ddl,UInt_t *buf){
 118   //This method packs the SDD digits in a proper 32 bits structure
 119   Int_t ix;
 120   Int_t iz;
 121   Int_t is;
 122   UInt_t word=0;
 123   UInt_t baseWord=0;
 124   Int_t ndigits = ITSdigits->GetEntries();
 125   AliITSdigit *digs;
 126   ofstream ftxt;
 127   Int_t digarr[512][256];
 128   for(Int_t i=0;i<512;i++){
 129     for(Int_t j=0;j<256;j++){
 130       digarr[i][j]=0;
 131     }
 132   }
 133   //word to select the 12 carlos for the 12 modules
 134   UInt_t carlosid=0;
 135   if(mod==0) carlosid=805306368;
 136   if(mod==1) carlosid=805306369;
 137   if(mod==2) carlosid=805306370;
 138   if(mod==3) carlosid=805306371;
 139   if(mod==4) carlosid=805306372;
 140   if(mod==5) carlosid=805306373;
 141   if(mod==6) carlosid=805306374;
 142   if(mod==7) carlosid=805306375;
 143   if(mod==8) carlosid=805306376;
 144   if(mod==9) carlosid=805306377;
 145   if(mod==10) carlosid=805306378;
 146   if(mod==11) carlosid=805306379;
 147
 148   fIndex++;
 149   buf[fIndex]=carlosid;
 150   Int_t first=0;
 151   Int_t last=0;
 152   Int_t diff=0;
 153   Int_t nbit=0;
 154   UInt_t word2=0;
 155   Bool_t flag = kFALSE;
 156   baseWord=0;
 157   Int_t bitinfo1[4] = {3,8,3,7}; //vector with info on bit for timebin info
 158   Int_t wordinfo1[4]= {0,0,0,0}; //vector with word info for timebin info
 159   Int_t bitinfo2[2] = {3,18};    //vector with info on bit for EOR (end of row) info
 160   Int_t wordinfo2[3]= {1,65593}; //vector with word info for anode info
 161
 162   /* for time bin info: word          n bits   meaning
 163                          0               3      next info is timebin
 164                          8               3      next word is 8 bit long
 165                        tb value          8      timebin value
 166                        n (2->7)          3      next info is n bit long
 167                         signal           n      signal value
 168
 169      for anode info:     1               3      next 18 bits are for EOR
 170                                                 increments the anode value
 171
 172                          EOR             18     error codes + other info
 173   */
 174
 175   if(ndigits){
 176     if (fVerbose==2)
 177       ftxt.open("SDDdigits.txt",ios::app);
 178     for (Int_t digit=0;digit<ndigits;digit++) {
 179       digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
 180       iz=digs->GetCoord1();  // Anode
 181       ix=digs->GetCoord2();  // Time
 182       is=digs->GetCompressedSignal();  // ADC Signal
 183       digarr[iz][ix]=is;
 184         if (fVerbose==2)
 185         ftxt<<"DDL:"<<ddl<<" MID:"<<modR<<" An:"<<iz<<" T:"<<ix<<" A:"<<is<<endl;
 186       if (is>255){Error("GetDigitsSDD", "bits words is needed)!!!");}
 187     }
 188
 189     for(Int_t anode=0;anode<512;anode++){
 190       if(flag){
 191         last = first+diff-1;
 192         AliBitPacking::PackWord(word2,baseWord,first,last);
 193         flag = kFALSE;
 194         first = last+1;
 195         diff=0;
 196       }
 197
 198
 199       if(anode == 256){
 200         last = 0;
 201         first = 0;
 202         flag = kFALSE;
 203         diff = 0;
 204         word2=0;
 205
 206       }
 207
 208       for(Int_t tb=0;tb<256;tb++){
 209         if(digarr[anode][tb]!=0){
 210           if(flag){
 211             last = first+diff-1;
 212             AliBitPacking::PackWord(word2,baseWord,first,last);
 213             flag = kFALSE;
 214             first = last+1;
 215             diff=0;
 216           }
 217           wordinfo1[1] = tb;
 218           //non lossy compression as it is done in Carlos
 219           //(data are already 10to8bit compressed by AMBRA
 220
 221           /* if value < 8  value = value - (1 << 2) (word is 2 bit long)
 222              if value < 16 value = value - (1 << 3) (word is 3 bit long)
 223              if value < 32 value = value - (1 << 4) (word is 4 bit long)
 224              if value < 64 value = value - (1 << 5) (word is 5 bit long)
 225              if value <128 value = value - (1 << 6) (word is 6 bit long)
 226              if value >=128value = value - (1 << 7) (word is 7 bit long)
 227
 228           */
 229           if(digarr[anode][tb]<8){
 230             bitinfo1[3] = 2;
 231             wordinfo1[2] = 2;
 232             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
 233           }
 234           if(digarr[anode][tb]>=8 && digarr[anode][tb]<16){
 235             bitinfo1[3] = 3;
 236             wordinfo1[2] = 3;
 237             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
 238           }
 239           if(digarr[anode][tb]>=16 && digarr[anode][tb]<32){
 240             bitinfo1[3] = 4;
 241             wordinfo1[2] = 4;
 242             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
 243           }
 244           if(digarr[anode][tb]>=32 && digarr[anode][tb]<64){
 245             bitinfo1[3] = 5;
 246             wordinfo1[2] = 5;
 247             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
 248           }
 249           if(digarr[anode][tb]>=64 && digarr[anode][tb]<128){
 250             bitinfo1[3] = 6;
 251             wordinfo1[2] = 6;
 252             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
 253           }
 254           if(digarr[anode][tb]>=128){
 255             bitinfo1[3] = 7;
 256             wordinfo1[2] = 7;
 257             wordinfo1[3] = digarr[anode][tb]-(1 << bitinfo1[3]);
 258           }
 259
 260           for(Int_t ie=0;ie<4;ie++){
 261
 262             if(flag){
 263               last = first+diff-1;
 264               AliBitPacking::PackWord(word2,baseWord,first,last);
 265               flag = kFALSE;
 266               first = last+1;
 267               diff=0;
 268             }
 269             last = first+bitinfo1[ie]-1;
 270             if(first < 30 && last < 30){
 271               AliBitPacking::PackWord(wordinfo1[ie],baseWord,first,last);
 272               first = last+1;
 273             }
 274             else{
 275               if(first<=29){
 276                 UInt_t w = AliBitPacking::UnpackWord(wordinfo1[ie],0,29-first);
 277                 AliBitPacking::PackWord(w,baseWord,first,29);
 278                 Int_t lb = 29-first+1;
 279                 diff = bitinfo1[ie]-lb;
 280                 word2 = AliBitPacking::UnpackWord(wordinfo1[ie],lb,lb+diff-1);
 281                 flag = kTRUE;
 282                 if(anode<256) word = 2;//channel 0 of carlos
 283                 else word = 3; //channel 1 of carlos
 284                 AliBitPacking::PackWord(word,baseWord,30,31);
 285                 fIndex++;
 286                 buf[fIndex]=baseWord;
 287                 first=0;
 288                 last = 0;
 289                 baseWord=0;
 290                 word = 0;
 291               }
 292               else{
 293                 word2 = wordinfo1[ie];
 294                 diff = bitinfo1[ie];
 295                 flag = kTRUE;
 296                 if(anode<256) word = 2; //channel 0 of carlos
 297                 else word = 3; //channel 1 of carlos
 298                 AliBitPacking::PackWord(word,baseWord,30,31);
 299                 fIndex++;
 300                 buf[fIndex]=baseWord;
 301                 first=0;
 302                 last=0;
 303                 baseWord=0;
 304                 word = 0;
 305               }
 306             }
 307           }
 308
 309         }//END IF
 310
 311       }//end loop on tb
 312
 313       for(Int_t i=0;i<2;i++){
 314         if(flag){
 315           last = first+diff-1;
 316           AliBitPacking::PackWord(word2,baseWord,first,last);
 317           flag = kFALSE;
 318           first = last+1;
 319           diff=0;
 320         }
 321
 322         word = wordinfo2[i];
 323         nbit = bitinfo2[i];
 324         last = first+nbit-1;
 325         if(first < 30 && last < 30){
 326           AliBitPacking::PackWord(word,baseWord,first,last); //3 bit code =1 -> next 18 bits for EOR
 327           first = last+1;
 328         }
 329
 330         else{
 331           if(first<=29){
 332             UInt_t w = AliBitPacking::UnpackWord(word,0,29-first);
 333             AliBitPacking::PackWord(w,baseWord,first,29);
 334             Int_t lb = 29-first+1;
 335             diff = nbit-lb;
 336             word2 = AliBitPacking::UnpackWord(word,lb,lb+diff-1);
 337             flag = kTRUE;
 338             if(anode<256) word = 2;
 339             else word = 3;
 340             AliBitPacking::PackWord(word,baseWord,30,31);
 341             fIndex++;
 342             buf[fIndex]=baseWord;
 343             first=0;
 344             last = 0;
 345             baseWord=0;
 346             if(anode==255){
 347               flag=kFALSE;
 348               word2=0;
 349             }
 350           }
 351           else{
 352             word2 = word;
 353             diff = nbit;
 354             flag = kTRUE;
 355             if(anode<256) word = 2;
 356             else word = 3;
 357             AliBitPacking::PackWord(word,baseWord,30,31);
 358             fIndex++;
 359             buf[fIndex]=baseWord;
 360             first=0;
 361             last=0;
 362             baseWord=0;
 363             if(anode==255){
 364               flag=kFALSE;
 365               word2=0;
 366             }
 367           }
 368         }
 369       }
 370     } //end for
 371
 372   }
 373   if(fVerbose==2)
 374     ftxt.close();
 375   return;
 376 }//end GetDigitsSDD
 377
 378 ////////////////////////////////////////////////////////////////////////////////////////
 379 //PIXEL
 380 //
 381
 382 void AliITSDDLRawData::GetDigitsSPD(TClonesArray *ITSdigits,Int_t mod,Int_t ddl, UInt_t *buf){
 383   //This method packs the SPD digits in a proper 32 structure
 384   //Since data is zero suppressed,the coordinates for the chip having zero digits
 385   //doesn't get listed in the galice.root file. However the SPD format requires
 386   //the empty chip to be written with chip header and chip trailer.
 387   //The index of the half stave is calculated as (mod/2).
 388   Int_t ix;
 389   Int_t iz;
 390   Int_t chipNo=0;
 391   UInt_t baseWord=0;
 392   UInt_t hitRow=0;
 393   Int_t chipHitCount=0;  //Number of Hit in the current chip
 394   Int_t previousChip=-1; //Previuos chip respect to the actual aone
 395   Int_t ndigits = ITSdigits->GetEntries(); //number of digits in the current module
 396   //cout<<"      Number of digits in the current module:"<<ndigits<<" module:"<<mod<<endl;
 397   AliITSdigit *digs;
 398   fHalfStaveModule++;    //It's a private variable used to distinguish between the firs
 399                          //and the second module of an Half Stave Module
 400   ofstream ftxt;
 401   if(ndigits){
 402     //loop over digits
 403     if (fVerbose==2)
 404       ftxt.open("SPDdigits.txt",ios::app);
 405     for (Int_t digit=0;digit<ndigits;digit++){
 406       digs = (AliITSdigit*)ITSdigits->UncheckedAt(digit);
 407       /*---------------------------------------------------------------------------
 408        *     Each module contains 5 read out chips of 256 rows and 32 columns.
 409        *     So, the cell number in Z direction varies from 0 to 159.  Therefore,
 410        *     to get the chip address (0 to 4), we need to divide column number by 32.
 411        *     ---------------------------------------------------------------------*/
 412       iz=digs->GetCoord1();  // Cell number in Z direction
 413       ix=digs->GetCoord2();  // Cell number in X direction
 414       chipNo=iz/32;
 415       if(fVerbose==2)
 416         ftxt<<"DDL:"<<ddl<<" Mod:"<<mod<<" Row:"<<ix<<" Col:"<<iz<<endl;
 417       hitRow=iz-chipNo*32;
 418       if(fHalfStaveModule){
 419         chipNo+=5;
 420         fHalfStaveModule=-1;
 421       }//end if
 422       if(previousChip==-1){
 423         //loop over chip without digits
 424         //Even if there aren't digits for a given chip
 425         //the chip header and the chip trailer are stored
 426         for(Int_t i=0;i<(iz/32);i++){
 427           if(chipNo>4)
 428             WriteChipHeader(i+5,(mod/2),baseWord);
 429           else
 430             WriteChipHeader(i,(mod/2),baseWord);
 431           WriteChipTrailer(buf,chipHitCount,baseWord);
 432           chipHitCount=0;
 433         }//end for
 434         WriteChipHeader(chipNo,(mod/2),baseWord);
 435         chipHitCount++;
 436         WriteHit(buf,ix,hitRow,baseWord);
 437         previousChip=chipNo;
 438       }//end if
 439       else{
 440         if(previousChip!=chipNo){
 441           WriteChipTrailer(buf,chipHitCount,baseWord);
 442           chipHitCount=0;
 443           for(Int_t i=previousChip+1;i<chipNo;i++){
 444             WriteChipHeader(i,(mod/2),baseWord);
 445             WriteChipTrailer(buf,0,baseWord);
 446             chipHitCount=0;
 447           }//end for
 448           WriteChipHeader(chipNo,(mod/2),baseWord);
 449           previousChip=chipNo;
 450         }//end if
 451         chipHitCount++;
 452         WriteHit(buf,ix,hitRow,baseWord);
 453       }//end else
 454     }//end for
 455     //Even if there aren't digits for a given chip
 456     //the chip header and the chip trailer are stored
 457     Int_t end=4;
 458     if(chipNo>4)end+=5;
 459     WriteChipTrailer(buf,chipHitCount,baseWord);
 460     chipHitCount=0;
 461     for(Int_t i=chipNo+1;i<=end;i++){
 462       WriteChipHeader(i,(mod/2),baseWord);
 463       WriteChipTrailer(buf,0,baseWord);
 464       chipHitCount=0;
 465     }//end for
 466   }//end if
 467   else{
 468     //In this module there aren't digits but
 469     //the chip header and chip trailer are store anyway
 470     if(fHalfStaveModule){
 471       chipNo=5;
 472       fHalfStaveModule=-1;
 473     }//end if
 474     for(Int_t i=0;i<5;i++){
 475       WriteChipHeader(chipNo+i,(mod/2),baseWord);
 476       WriteChipTrailer(buf,chipHitCount,baseWord);
 477       chipHitCount=0;
 478     }//end for
 479   }//end else
 480   if(fVerbose==2)
 481     ftxt.close();
 482   return;
 483 }//end GetDigitsSPD
 484
 485 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 486
 487 Int_t AliITSDDLRawData::RawDataSPD(TBranch* branch){
 488   //This method creates the Raw data files for SPD detectors
 489   const Int_t kSize=21000; //256*32*5=40960 max number of digits per module
 490   UInt_t buf[kSize];      //One buffer cell can contain 2 digits
 491   fIndex=-1;
 492
 493   TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
 494   char fileName[15];
 495   AliFstream* outfile;         // logical name of the output file
 496   AliRawDataHeader header;
 497
 498   //loop over DDLs
 499   for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSPD");i++){
 500     strcpy(fileName,AliDAQ::DdlFileName("ITSSPD",i)); //The name of the output file.
 501     outfile = new AliFstream(fileName);
 502     //write Dummy DATA HEADER
 503     UInt_t dataHeaderPosition=outfile->Tellp();
 504     outfile->WriteBuffer((char*)(&header),sizeof(header));
 505     //Loops over Modules of a particular DDL
 506     for (Int_t mod=0; mod<AliITSRawStreamSPD::kModulesPerDDL; mod++){
 507       Int_t moduleNumber = AliITSRawStreamSPD::GetModuleNumber(i, mod);
 508       digits->Clear();
 509       branch->GetEvent(moduleNumber);
 510       //For each Module, buf contains the array of data words in Binary format
 511       //fIndex gives the number of 32 bits words in the buffer for each module
 512       GetDigitsSPD(digits,mod,i,buf);
 513       outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
 514       for(Int_t i=0;i<(fIndex+1);i++){
 515         buf[i]=0;
 516       }//end for
 517       fIndex=-1;
 518     }//end for
 519
 520     //Write REAL DATA HEADER
 521     UInt_t currentFilePosition=outfile->Tellp();
 522     outfile->Seekp(dataHeaderPosition);
 523     header.fSize=currentFilePosition-dataHeaderPosition;
 524     outfile->WriteBuffer((char*)(&header),sizeof(header));
 525     delete outfile;
 526   }//end for
 527
 528   return 0;
 529 }
 530
 531 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 532
 533 Int_t AliITSDDLRawData::RawDataSSD(TBranch* branch){
 534
 535   //This method creates the Raw data files for SSD detectors
 536   const Int_t kSize=1536;//768*2 Number of stripe * number of sides(N and P)
 537   UInt_t buf[kSize];
 538   fIndex=-1;
 539
 540   TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
 541   char fileName[15];
 542   AliFstream* outfile;         // logical name of the output file
 543   AliRawDataHeader header;
 544
 545   //loop over DDLs
 546   for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSSD");i++){
 547     strcpy(fileName,AliDAQ::DdlFileName("ITSSSD",i)); //The name of the output file.
 548     outfile = new AliFstream(fileName);
 549     //write Dummy DATA HEADER
 550     UInt_t dataHeaderPosition=outfile->Tellp();
 551     outfile->WriteBuffer((char*)(&header),sizeof(header));
 552
 553     //Loops over Modules of a particular DDL
 554     for (Int_t mod=0; mod<AliITSRawStreamSSD::kModulesPerDDL; mod++){
 555       Int_t moduleNumber = AliITSRawStreamSSD::GetModuleNumber(i, mod);
 556       if(moduleNumber!=-1){
 557         digits->Clear();
 558         branch->GetEvent(moduleNumber);
 559         //For each Module, buf contains the array of data words in Binary format
 560         //fIndex gives the number of 32 bits words in the buffer for each module
 561         GetDigitsSSD(digits,mod,moduleNumber,i,buf);
 562         outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
 563         fIndex=-1;
 564       }//end if
 565     }//end for
 566
 567     //Write REAL DATA HEADER
 568     UInt_t currentFilePosition=outfile->Tellp();
 569     outfile->Seekp(dataHeaderPosition);
 570     header.fSize=currentFilePosition-dataHeaderPosition;
 571     header.SetAttribute(0);  // valid data
 572     outfile->WriteBuffer((char*)(&header),sizeof(header));
 573     delete outfile;
 574   }//end for
 575
 576   return 0;
 577 }
 578
 579 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 580
 581 Int_t AliITSDDLRawData::RawDataSDD(TBranch* branch){
 582     //This method creates the Raw data files for SDD detectors
 583   const Int_t kSize=131072; //256*512
 584   UInt_t buf[kSize];
 585   fIndex=-1;
 586
 587   TClonesArray*& digits = * (TClonesArray**) branch->GetAddress();
 588   char fileName[15];
 589   AliFstream* outfile;             // logical name of the output file
 590   AliRawDataHeader header;
 591   UInt_t skippedword = AliBitPacking::PackWord(2,skippedword,0,31);
 592
 593   //loop over DDLs
 594   for(Int_t i=0;i<AliDAQ::NumberOfDdls("ITSSDD");i++){
 595     strcpy(fileName,AliDAQ::DdlFileName("ITSSDD",i)); //The name of the output file.
 596     outfile = new AliFstream(fileName);
 597     //write Dummy DATA HEADER
 598     UInt_t dataHeaderPosition=outfile->Tellp();
 599     outfile->WriteBuffer((char*)(&header),sizeof(header));
 600
 601     //first 9 "dummy" words to be skipped
 602     for(Int_t iw=0;iw<9;iw++){
 603         outfile->WriteBuffer((char*)(&skippedword),sizeof(skippedword));
 604     }
 605
 606     //Loops over Modules of a particular DDL
 607     for (Int_t mod=0; mod<AliITSRawStreamSDD::kModulesPerDDL; mod++){
 608       Int_t moduleNumber = AliITSRawStreamSDD::GetModuleNumber(i, mod);
 609       if(moduleNumber!=-1){
 610         digits->Clear();
 611         branch->GetEvent(moduleNumber);
 612
 613         //For each Module, buf contains the array of data words in Binary format
 614         //fIndex gives the number of 32 bits words in the buffer for each module
 615         //      cout<<"MODULE NUMBER:"<<mapSDD[i][mod]<<endl;
 616         GetDigitsSDD(digits,mod,moduleNumber,i,buf);
 617         outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
 618         fIndex=-1;
 619       }//end if
 620     }//end for
 621
 622     //Write REAL DATA HEADER
 623     UInt_t currentFilePosition=outfile->Tellp();
 624     outfile->Seekp(dataHeaderPosition);
 625     header.fSize=currentFilePosition-dataHeaderPosition;
 626     header.SetAttribute(0);  // valid data
 627     outfile->WriteBuffer((char*)(&header),sizeof(header));
 628     delete outfile;
 629   }//end for
 630
 631   return 0;
 632 }
 633
 634 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 635
 636 void AliITSDDLRawData::WriteChipHeader(Int_t ChipAddr,Int_t halfStave,UInt_t &BaseWord){
 637   //This method writes a chip header
 638   //cout<<"Chip: "<<ChipAddr<<" Half Stave module:"<<halfStave<<endl;
 639   BaseWord=0;
 640   AliBitPacking::PackWord(ChipAddr,BaseWord,16,19);
 641   //  At the moment the event count is always 0 (bits 20-26)
 642   AliBitPacking::PackWord(0,BaseWord,20,26);
 643   AliBitPacking::PackWord(halfStave,BaseWord,27,29);
 644   AliBitPacking::PackWord(0x1,BaseWord,30,31);
 645   return;
 646 }//end WriteChipHeader
 647
 648 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 649
 650 void  AliITSDDLRawData::WriteChipTrailer(UInt_t *buf,Int_t ChipHitCount,UInt_t &BaseWord){
 651   //This method writes a chip trailer
 652   //pixel fill word
 653   if((ChipHitCount%2)!=0){
 654     AliBitPacking::PackWord(0xC000,BaseWord,16,31);
 655   }
 656   AliBitPacking::PackWord(ChipHitCount,BaseWord,0,13);
 657   AliBitPacking::PackWord(0x0,BaseWord,14,15);
 658   fIndex++;
 659   buf[fIndex]=BaseWord;
 660   BaseWord=0;
 661   return;
 662 }//end WriteChipTrailer
 663
 664 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 665
 666 void  AliITSDDLRawData::WriteHit(UInt_t *buf,Int_t RowAddr,Int_t HitAddr,UInt_t &BaseWord){
 667   //This method writs an hit
 668   if(!BaseWord){
 669     AliBitPacking::PackWord(HitAddr,BaseWord,16,20);
 670     AliBitPacking::PackWord(RowAddr,BaseWord,21,28);
 671     AliBitPacking::PackWord(2,BaseWord,30,31);
 672   }//end if
 673   else{
 674     AliBitPacking::PackWord(HitAddr,BaseWord,0,4);
 675     AliBitPacking::PackWord(RowAddr,BaseWord,5,12);
 676     AliBitPacking::PackWord(2,BaseWord,14,15);
 677     fIndex++;
 678     buf[fIndex]=BaseWord;
 679     BaseWord=0;
 680   }//end else
 681   return;
 682 }//end WriteHit
 683