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