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