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