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