TOF/AliTOFRawStream.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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 /*
  17 $Log$
  18 Revision 1.17  2007/05/03 08:53:50  decaro
  19 Coding convention: RS3 violation -> suppression
  20
  21 Revision 1.16  2007/05/03 08:22:22  decaro
  22 Coding convention: RN17 violation -> suppression
  23
  24 Revision 1.15  2007/04/30 15:22:06  arcelli
  25 Change TOF digit Time, Tot etc to int type
  26
  27 Revision 1.14  2007/04/27 11:11:53  arcelli
  28 updates for the new decoder
  29
  30 Revision 1.13  2007/03/16 11:46:35  decaro
  31 Coding convention: RN17 rule violation -> suppression
  32
  33 Revision 1.12  2007/02/22 09:43:45  decaro
  34 Added AliTOFRawStream::GetIndex method for online calibration (C.Zampolli)
  35
  36 Revision 1.11  2007/02/20 15:57:00  decaro
  37 Raw data update: to read the TOF raw data defined in UNPACKED mode
  38
  39 Revision 1.10  2006/12/15 14:01:38  cvetan
  40 Memory leak fixed
  41
  42 Revision 1.9  2006/10/13 11:22:27  arcelli
  43 remove warnings due to uninitialized AliTOFtdcDigit data members
  44
  45 Revision 1.8  2006/08/22 13:30:17  arcelli
  46 removal of effective c++ warnings (C.Zampolli)
  47
  48 Revision 1.7  2006/08/10 14:46:54  decaro
  49 TOF raw data format: updated version
  50
  51 Revision 1.6.1  2006/06/28 A. De Caro, R. Preghenella:
  52         Update TOF raw data format
  53         according to the final version
  54         (see the ALICE internal note in preparation
  55          'ALICE TOF raw data format')
  56         Added the methods for the correspoonding numbering
  57          between the equipment IDs and the volume IDs:
  58            Equip2VolNPlate(...)
  59            Equip2VolNStrip(...)
  60            Equip2VolNPad(...)
  61
  62 Revision 0.02  2005/07/28 A. De Caro:
  63         Update format TOF raw data
  64                (temporary solution)
  65         Correction of few wrong corrispondences
  66                between 'software' and 'hardware' numberings
  67
  68 Revision 0.01  2005/07/22 A. De Caro
  69         Implement methods Next()
  70                           GetSector(),
  71                           GetPlate(),
  72                           GetStrip(),
  73                           GetPadZ(),
  74                           GetPadX()
  75 */
  76
  77 ////////////////////////////////////////////////////////////////////////
  78 //                                                                    //
  79 //     This class provides access to TOF raw data in DDL files.       //
  80 //                                                                    //
  81 //      It loops over all TOF raw data given by the AliRawReader.     //
  82 //                                                                    //
  83 ////////////////////////////////////////////////////////////////////////
  84
  85
  86 #include "TClonesArray.h"
  87
  88 #include "AliDAQ.h"
  89 #include "AliLog.h"
  90 #include "AliRawReader.h"
  91
  92 #include "AliTOFGeometry.h"
  93 #include "AliTOFGeometryV5.h"
  94 #include "AliTOFrawData.h"
  95 #include "AliTOFRawMap.h"
  96 #include "AliTOFRawStream.h"
  97
  98
  99 ClassImp(AliTOFRawStream)
 100
 101
 102 //_____________________________________________________________________________
 103 AliTOFRawStream::AliTOFRawStream(AliRawReader* rawReader):
 104   fRawReader(rawReader),
 105   //  fTOFrawData(new TClonesArray("AliTOFrawData",1000)),
 106   fTOFrawData(0x0),
 107   fDecoder(new AliTOFDecoder()),
 108   fDDL(-1),
 109   fTRM(-1),
 110   fTRMchain(-1),
 111   fTDC(-1),
 112   fTDCchannel(-1),
 113   fTime(-1),
 114   fToT(-1),
 115   fLeadingEdge(-1),
 116   fTrailingEdge(-1),
 117   fErrorFlag(-1),
 118   fSector(-1),
 119   fPlate(-1),
 120   fStrip(-1),
 121   fPadX(-1),
 122   fPadZ(-1),
 123   fTOFGeometry(new AliTOFGeometryV5()),
 124   fPackedDigits(0),
 125   fWordType(-1),
 126   fSlotID(-1),
 127   fACQ(-1),
 128   fPSbit(-1),
 129   fTDCerrorFlag(-1),
 130   fInsideDRM(kFALSE),
 131   fInsideTRM(kFALSE),
 132   fInsideLTM(kFALSE),
 133   fInsideTRMchain0(kFALSE),
 134   fInsideTRMchain1(kFALSE)
 135 {
 136   //
 137   // create an object to read TOF raw digits
 138   //
 139
 140   for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
 141     fDataBuffer[i]=new AliTOFHitDataBuffer();
 142     fPackedDataBuffer[i]=new AliTOFHitDataBuffer();
 143   }
 144
 145   fTOFrawData = new TClonesArray("AliTOFrawData",1000);
 146   fTOFrawData->SetOwner();
 147
 148   fRawReader->Reset();
 149   fRawReader->Select("TOF");
 150 }
 151
 152 //_____________________________________________________________________________
 153 AliTOFRawStream::AliTOFRawStream():
 154   fRawReader(0x0),
 155   //  fTOFrawData(new TClonesArray("AliTOFrawData",1000)),
 156   fTOFrawData(0x0),
 157   fDecoder(new AliTOFDecoder()),
 158   fDDL(-1),
 159   fTRM(-1),
 160   fTRMchain(-1),
 161   fTDC(-1),
 162   fTDCchannel(-1),
 163   fTime(-1),
 164   fToT(-1),
 165   fLeadingEdge(-1),
 166   fTrailingEdge(-1),
 167   fErrorFlag(-1),
 168   fSector(-1),
 169   fPlate(-1),
 170   fStrip(-1),
 171   fPadX(-1),
 172   fPadZ(-1),
 173   fTOFGeometry(new AliTOFGeometryV5()),
 174   fPackedDigits(0),
 175   fWordType(-1),
 176   fSlotID(-1),
 177   fACQ(-1),
 178   fPSbit(-1),
 179   fTDCerrorFlag(-1),
 180   fInsideDRM(kFALSE),
 181   fInsideTRM(kFALSE),
 182   fInsideLTM(kFALSE),
 183   fInsideTRMchain0(kFALSE),
 184   fInsideTRMchain1(kFALSE)
 185 {
 186   //
 187   // default ctr
 188   //
 189   for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
 190     fDataBuffer[i]=new AliTOFHitDataBuffer();
 191     fPackedDataBuffer[i]=new AliTOFHitDataBuffer();
 192   }
 193
 194   fTOFrawData = new TClonesArray("AliTOFrawData",1000);
 195   fTOFrawData->SetOwner();
 196 }
 197
 198 //_____________________________________________________________________________
 199 AliTOFRawStream::AliTOFRawStream(const AliTOFRawStream& stream) :
 200   TObject(stream),
 201   fRawReader(0x0),
 202   //  fTOFrawData(new TClonesArray("AliTOFrawData",1000)),
 203   fTOFrawData(0x0),
 204   fDecoder(new AliTOFDecoder()),
 205   fDDL(-1),
 206   fTRM(-1),
 207   fTRMchain(-1),
 208   fTDC(-1),
 209   fTDCchannel(-1),
 210   fTime(-1),
 211   fToT(-1),
 212   fLeadingEdge(-1),
 213   fTrailingEdge(-1),
 214   fErrorFlag(-1),
 215   fSector(-1),
 216   fPlate(-1),
 217   fStrip(-1),
 218   fPadX(-1),
 219   fPadZ(-1),
 220   fTOFGeometry(new AliTOFGeometryV5()),
 221   fPackedDigits(0),
 222   fWordType(-1),
 223   fSlotID(-1),
 224   fACQ(-1),
 225   fPSbit(-1),
 226   fTDCerrorFlag(-1),
 227   fInsideDRM(kFALSE),
 228   fInsideTRM(kFALSE),
 229   fInsideLTM(kFALSE),
 230   fInsideTRMchain0(kFALSE),
 231   fInsideTRMchain1(kFALSE)
 232 {
 233   //
 234   // copy constructor
 235   //
 236
 237   fRawReader = stream.fRawReader;
 238
 239   fTOFrawData = stream.fTOFrawData;
 240
 241   fDDL = stream.fDDL;
 242   fTRM = stream.fTRM;
 243   fTRMchain = stream.fTRMchain;
 244   fTDC = stream.fTDC;
 245   fTDCchannel = stream.fTDCchannel;
 246   fTime = stream.fTime;
 247   fToT = stream.fToT;
 248   fLeadingEdge = stream.fLeadingEdge;
 249   fTrailingEdge = stream.fTrailingEdge;
 250
 251   fErrorFlag = stream.fErrorFlag;
 252
 253   fSector = stream.fSector;
 254   fPlate = stream.fPlate;
 255   fStrip = stream.fStrip;
 256   fPadX = stream.fPadX;
 257   fPadZ = stream.fPadZ;
 258
 259   fTOFGeometry = stream.fTOFGeometry;
 260
 261   fPackedDigits = stream.fPackedDigits;
 262
 263   fWordType = stream.fWordType;
 264   fSlotID = stream.fSlotID;
 265   fACQ = stream.fACQ;
 266   fPSbit = stream.fPSbit;
 267   fTDCerrorFlag = stream.fTDCerrorFlag;
 268   fInsideDRM = stream.fInsideDRM;
 269   fInsideTRM = stream.fInsideTRM;
 270   fInsideLTM = stream.fInsideLTM;
 271   fInsideTRMchain0 = stream.fInsideTRMchain0;
 272   fInsideTRMchain1 = stream.fInsideTRMchain1;
 273
 274   for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
 275     fDataBuffer[i]= new AliTOFHitDataBuffer(*stream.fDataBuffer[i]);
 276     fPackedDataBuffer[i]= new AliTOFHitDataBuffer(*stream.fPackedDataBuffer[i]);
 277   }
 278
 279   fTOFrawData = new TClonesArray(*stream.fTOFrawData);
 280
 281 }
 282
 283 //_____________________________________________________________________________
 284 AliTOFRawStream& AliTOFRawStream::operator = (const AliTOFRawStream& stream)
 285 {
 286   //
 287   // assignment operator
 288   //
 289
 290   fRawReader = stream.fRawReader;
 291
 292   fTOFrawData = stream.fTOFrawData;
 293
 294   fDDL = stream.fDDL;
 295   fTRM = stream.fTRM;
 296   fTRMchain = stream.fTRMchain;
 297   fTDC = stream.fTDC;
 298   fTDCchannel = stream.fTDCchannel;
 299   fTime = stream.fTime;
 300   fToT = stream.fToT;
 301   fLeadingEdge = stream.fLeadingEdge;
 302   fTrailingEdge = stream.fTrailingEdge;
 303   fErrorFlag = stream.fErrorFlag;
 304
 305   fSector = stream.fSector;
 306   fPlate = stream.fPlate;
 307   fStrip = stream.fStrip;
 308   fPadX = stream.fPadX;
 309   fPadZ = stream.fPadZ;
 310
 311   fTOFGeometry = stream.fTOFGeometry;
 312
 313   fPackedDigits = stream.fPackedDigits;
 314
 315   fWordType = stream.fWordType;
 316   fSlotID = stream.fSlotID;
 317   fACQ = stream.fACQ;
 318   fPSbit = stream.fPSbit;
 319   fTDCerrorFlag = stream.fTDCerrorFlag;
 320   fInsideDRM = stream.fInsideDRM;
 321   fInsideTRM = stream.fInsideTRM;
 322   fInsideLTM = stream.fInsideLTM;
 323   fInsideTRMchain0 = stream.fInsideTRMchain0;
 324   fInsideTRMchain1 = stream.fInsideTRMchain1;
 325
 326   for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
 327     fDataBuffer[i] = stream.fDataBuffer[i];
 328     fPackedDataBuffer[i] = stream.fPackedDataBuffer[i];
 329   }
 330
 331   fTOFrawData = stream.fTOFrawData;
 332
 333   return *this;
 334
 335 }
 336
 337 //_____________________________________________________________________________
 338 AliTOFRawStream::~AliTOFRawStream()
 339 {
 340 // destructor
 341
 342   fPackedDigits = 0;
 343
 344   delete fTOFGeometry;
 345
 346   for (Int_t i=0;i<72;i++){
 347     delete fDataBuffer[i];
 348     delete fPackedDataBuffer[i];
 349   }
 350
 351   delete fDecoder;
 352
 353   fTOFrawData->Clear();
 354   delete fTOFrawData;
 355 }
 356
 357
 358 //_____________________________________________________________________________
 359
 360 void AliTOFRawStream::LoadRawData(Int_t indexDDL)
 361 {
 362
 363   /*
 364     for (Int_t indexDDL = 0;
 365     indexDDL < AliDAQ::NumberOfDdls("TOF");
 366     indexDDL++) {
 367   */
 368
 369   fTOFrawData = new TClonesArray("AliTOFrawData",1000); //potential memory leak
 370     //fTOFrawData->Clear();
 371   fPackedDigits = 0;
 372
 373   // create raw data map
 374   AliTOFRawMap *rawMap = new AliTOFRawMap(fTOFrawData);
 375   rawMap->Clear();
 376
 377   Int_t slot[4] = {-1, -1, -1, -1};
 378
 379   fRawReader->Reset();
 380   fRawReader->Select("TOF", indexDDL, indexDDL);
 381
 382   Bool_t signal = kFALSE;
 383
 384
 385
 386   while(Next()) {
 387
 388     signal = (fSector!=-1 && fPlate!=-1 && fStrip!=-1 && fPadZ!=-1 && fPadX!=-1);
 389     if (signal) {
 390       //printf("  %2i  %1i  %2i  %1i  %2i  \n", fSector, fPlate, fStrip, fPadZ, fPadX);
 391
 392       slot[0] = fTRM;
 393       slot[1] = fTRMchain;
 394       slot[2] = fTDC;
 395       slot[3] = fTDCchannel;
 396
 397       if (rawMap->TestHit(slot) != kEmpty) {
 398
 399         AliTOFrawData *rawDigit = static_cast<AliTOFrawData*>(rawMap->GetHit(slot));
 400
 401         if (rawDigit->GetLeading()!=-1 && rawDigit->GetTrailing()==-1 &&
 402             fLeadingEdge==-1 && fTrailingEdge!=-1) {
 403
 404           rawDigit->Update(fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
 405         }
 406         else if ( ((rawDigit->GetTOF()!=-1 || rawDigit->GetLeading()!=-1 || rawDigit->GetTrailing()!=-1) &&
 407                    (fLeadingEdge!=-1 || fTrailingEdge!=-1 || fTime!=-1) )
 408
 409 /*      else if ( ((rawDigit->GetTOF()!=-1 || rawDigit->GetLeading()!=-1 || rawDigit->GetTrailing()!=-1) &&
 410                    (fTime!=-1 || fLeadingEdge!=-1 || fTrailingEdge!=-1))*/  /*||
 411                   (rawDigit->GetLeading()==-1 && rawDigit->GetTrailing()!=-1 &&
 412                   fLeadingEdge!=-1 && fTrailingEdge==-1) */)
 413           {
 414
 415           TClonesArray &arrayTofRawData =  *fTOFrawData;
 416           new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(fTRM, fTRMchain, fTDC, fTDCchannel, fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
 417
 418         rawMap->SetHit(slot);
 419
 420         }
 421
 422
 423       }
 424       else {
 425
 426         TClonesArray &arrayTofRawData =  *fTOFrawData;
 427         new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(fTRM, fTRMchain, fTDC, fTDCchannel, fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
 428
 429         rawMap->SetHit(slot);
 430
 431       } // else if (rawMap->TestHit(slot) == kEmpty)
 432
 433     } // if (signal)
 434
 435   } // closed -> while (Next())
 436
 437     /*
 438       fDDL  = fRawReader->GetDDLID();
 439
 440       for (Int_t ii=0; ii<fTOFrawData->GetEntriesFast(); ii++) {
 441
 442       AliTOFrawData *dummy = (AliTOFrawData*)fTOFrawData->UncheckedAt(ii);
 443
 444       fTRM = dummy->GetTRM();
 445       fTRMchain = dummy->GetTRMchain();
 446       fTDC = dummy->GetTDC();
 447       fTDCchannel = dummy->GetTDCchannel();
 448
 449       SetSector();
 450       SetPlate();
 451       SetStrip();
 452       SetPadZ();
 453       SetPadX();
 454
 455       printf("  %2i, %2i %1i, %2i, %1i  -->  %2i, %1i, %2i, %1i, %2i  \n",
 456              fDDL, fTRM, fTRMchain, fTDC, fTDCchannel,
 457              fSector, fPlate, fStrip, fPadZ, fPadX);
 458
 459              } // closed loop on TOF raw data TClonesArray
 460     */
 461
 462     //} // closed loop on indexDDL
 463
 464
 465
 466 }
 467
 468 //_____________________________________________________________________________
 469 Bool_t AliTOFRawStream::Next()
 470 {
 471   //
 472   // Read next 32-bit word in TOF raw data files
 473   // returns kFALSE if there is no word left
 474   //
 475
 476   UInt_t data;
 477
 478   if (!fRawReader->ReadNextInt(data)) return kFALSE;
 479
 480   if (fSector!=-1 && fPlate!=-1 && fStrip!=-1 && fPadZ!=-1 && fPadX!=-1) {
 481     fSector = -1;
 482     fPlate  = -1;
 483     fStrip  = -1;
 484     fPadZ   = -1;
 485     fPadX   = -1;
 486     fTime   = -1;
 487     fToT    = -1;
 488     fLeadingEdge  = -1;
 489     fTrailingEdge = -1;
 490   }
 491
 492   fDDL  = fRawReader->GetDDLID();
 493
 494   fWordType = GetField(data,WORD_TYPE_MASK,WORD_TYPE_POSITION);
 495
 496   switch (fWordType) { // switch word type
 497
 498   case GLOBAL_HEADER_TYPE: // global header
 499     fSlotID = GetField(data, HEADER_SLOT_ID_MASK, HEADER_SLOT_ID_POSITION);
 500     fTRM = fSlotID;
 501
 502
 503     switch (fSlotID) { // switch global header slot ID
 504
 505     case DRM_ID_NUMBER: //DRM global header
 506       if (fInsideDRM) { // unexpected DRM global headers -> exit
 507         break;
 508       }
 509       fInsideDRM = kTRUE; // DRM global header accepted
 510       break;
 511
 512     case LTM_ID_NUMBER: // LTM global header
 513       if (fInsideLTM) { // unexpected LTM global headers -> exit
 514         break;
 515       }
 516       fInsideLTM = kTRUE; // LTM global header accepted
 517       break;
 518
 519     case  3: //TRM header
 520     case  4: //TRM header
 521     case  5: //TRM header
 522     case  6: //TRM header
 523     case  7: //TRM header
 524     case  8: //TRM header
 525     case  9: //TRM header
 526     case 10: //TRM header
 527     case 11: //TRM header
 528     case 12: //TRM header
 529       if (fInsideTRM) { // unexpected TRM global headers -> exit
 530         break;
 531       }
 532       fInsideTRM = kTRUE; // TRM global header accepted
 533       fACQ =  GetField(data,TRM_ACQ_BITS_MASK,TRM_ACQ_BITS_POSITION);
 534       break;
 535
 536     default: // unexpected global header slot ID
 537       break;
 538
 539     } //end switch global header slot id
 540
 541     break;
 542
 543
 544   case GLOBAL_TRAILER_TYPE: // global trailer
 545     fSlotID = GetField(data,HEADER_SLOT_ID_MASK,HEADER_SLOT_ID_POSITION);
 546
 547
 548     switch (fSlotID) { // switch global trailer slot ID
 549
 550     case DRM_ID_NUMBER: // DRM global trailer
 551       if (!fInsideDRM) { // unexpected DRM global trailers -> exit
 552         break;
 553       }
 554       fInsideDRM = kFALSE; // DRM global trailer accepted
 555       fInsideTRM = kFALSE;
 556       fInsideLTM = kFALSE;
 557       fInsideTRMchain0 = kFALSE;
 558       fInsideTRMchain1 = kFALSE;
 559       fSector = -1;
 560       fPlate  = -1;
 561       fStrip  = -1;
 562       fPadZ   = -1;
 563       fPadX   = -1;
 564       fDDL        = -1;
 565       fTRM        = -1;
 566       fTDC        = -1;
 567       fTRMchain   = -1;
 568       fTDCchannel = -1;
 569       fTime = -1;
 570       fToT  = -1;
 571       fLeadingEdge  = -1;
 572       fTrailingEdge = -1;
 573       fErrorFlag = -1;
 574       fACQ   = -1;
 575       fPSbit = -1;
 576       fTDCerrorFlag = -1;
 577       break;
 578     case LTM_ID_NUMBER: // LTM global trailer
 579       if (!fInsideLTM) { // unexpected LTM global trailer -> exit
 580         break;
 581       }
 582       fInsideLTM = kFALSE; // LTM global trailer accepted
 583       break;
 584     case 15: //TRM global trailer
 585       if (!fInsideTRM) { // unexpected TRM global trailers -> exit
 586         break;
 587       }
 588       fInsideTRM = kFALSE; // TRM global trailer accepted
 589       break;
 590     default: // unexpected global trailer slot ID
 591       break;
 592     } //end switch global trailer slot id
 593
 594
 595     break;
 596
 597
 598   case ERROR_TYPE: // TDC error
 599     fTDC          = GetField(data,TRM_TDC_ERROR_TDC_ID_MASK,TRM_TDC_ERROR_TDC_ID_POSITION);
 600     fTDCerrorFlag = GetField(data,TRM_TDC_ERROR_FLAGS_MASK,TRM_TDC_ERROR_FLAGS_POSITION);
 601     break;
 602
 603
 604   case FILLER_TYPE: // filler
 605     break;
 606
 607
 608   default: // other word types
 609
 610     if (fInsideTRM) { // inside TRM
 611
 612       switch (fWordType) { // switch word type inside TRM
 613       case TRM_CHAIN0_HEADER_TYPE: // TRM chain0 header
 614         if (fInsideTRMchain0) { // unexpected TRM chain0 header
 615           break;
 616         }
 617         fInsideTRMchain0 = kTRUE;
 618         fTRMchain = 0;
 619         break;
 620       case TRM_CHAIN0_TRAILER_TYPE: // TRM chain0 trailer
 621         if (!fInsideTRMchain0) { // unexpected TRM chain0 trailer
 622           break;
 623         }
 624         fInsideTRMchain0 = kFALSE;
 625         fTRMchain = -1;
 626         break;
 627       case TRM_CHAIN1_HEADER_TYPE: // TRM chain1 header
 628         if (fInsideTRMchain1) { // unexpected TRM chain1 header
 629           break;
 630         }
 631         fInsideTRMchain1 = kTRUE;
 632         fTRMchain = 1;
 633         break;
 634       case TRM_CHAIN1_TRAILER_TYPE: // TRM chain1 trailer
 635         if (!fInsideTRMchain1) { // unexpected TRM chain1 trailer
 636           break;
 637         }
 638         fInsideTRMchain1 = kFALSE;
 639         fTRMchain = -1;
 640         break;
 641       } // end switch word type inside TRM
 642
 643     } // end if (fInsideTRM)
 644
 645
 646     if (
 647         ((fInsideTRMchain0&&!fInsideTRMchain1) || (!fInsideTRMchain0&&fInsideTRMchain1))
 648         && fWordType!=TRM_CHAIN0_HEADER_TYPE && fWordType!=TRM_CHAIN0_TRAILER_TYPE
 649         && fWordType!=TRM_CHAIN1_HEADER_TYPE && fWordType!=TRM_CHAIN1_TRAILER_TYPE
 650         ){ // inside TRM chains
 651
 652       fPSbit      = GetField(data,TRM_PS_BITS_MASK,TRM_PS_BITS_POSITION);
 653       fTDC        = GetField(data,TRM_TDC_ID_MASK,TRM_TDC_ID_POSITION);
 654       fTDCchannel = GetField(data,TRM_CHAN_MASK,TRM_CHAN_POSITION);
 655       fErrorFlag  = GetField(data,TRM_E_BIT_MASK,TRM_E_BIT_POSITION);
 656
 657       SetSector();
 658       SetPlate();
 659       SetStrip();
 660       SetPadZ();
 661       SetPadX();
 662
 663
 664       switch (fPSbit) { // switch fPSbit bits inside TRM chains
 665
 666       case 0: // packing ok, digit time and TOT
 667         fToT  = GetField(data,TRM_TOT_WIDTH_MASK, TRM_TOT_WIDTH_POSITION);
 668         fTime = GetField(data,TRM_DIGIT_TIME_MASK,TRM_DIGIT_TIME_POSITION);
 669         break;
 670
 671       case 1: // leading edge digit, long digit time, no TOT
 672         //fToT  = -1;
 673         //fTime  = -1;
 674         fLeadingEdge = GetField(data,TRM_LONG_DIGIT_TIME_MASK,TRM_LONG_DIGIT_TIME_POSITION);
 675         break;
 676
 677       case 2: // trailing edge digit, long digit time, no TOT
 678         //fToT  = -1;
 679         //fTime  = -1;
 680         fTrailingEdge = GetField(data,TRM_LONG_DIGIT_TIME_MASK,TRM_LONG_DIGIT_TIME_POSITION);
 681         break;
 682
 683       case 3: // TOT overflow
 684         fToT  = GetField(data,TRM_TOT_WIDTH_MASK, TRM_TOT_WIDTH_POSITION);
 685         fTime = GetField(data,TRM_DIGIT_TIME_MASK,TRM_DIGIT_TIME_POSITION);
 686         break;
 687
 688       } // end switch PS bits inside TRM chains
 689
 690     } // end if is inside TRM chains
 691
 692   } // end switch on fWordType
 693
 694
 695   return kTRUE;
 696
 697 }
 698 //_____________________________________________________________________________
 699
 700 void AliTOFRawStream::SetSector()
 701 {
 702   //
 703   // Evaluate the TOF sector number -> [ 0;17]
 704   // corresponding to the TOF equipment IDs:
 705   //                                  fDDL        -> [ 0;71]
 706   //                                  fTRM        -> [ 3;12]
 707   //                                  fTRMchain   -> [ 0; 1]
 708   //                                  fTDC        -> [ 0;14]
 709   //                                  fTDCchannel -> [ 0; 7]
 710   //
 711
 712   Int_t iSector = -1;
 713
 714   if (!(fDDL==-1)) iSector = Int_t((Float_t)(fDDL)/AliTOFGeometry::NDDL());
 715
 716   fSector = iSector;
 717
 718 }
 719 //_____________________________________________________________________________
 720
 721
 722 void AliTOFRawStream::SetPlate()
 723 {
 724   //
 725   // Evaluate the TOF plate number ->[ 0; 4]
 726   // corresponding to the TOF equipment IDs:
 727   //                                  fDDL        -> [ 0;71]
 728   //                                  fTRM        -> [ 3;12]
 729   //                                  fTRMchain   -> [ 0; 1]
 730   //                                  fTDC        -> [ 0;14]
 731   //                                  fTDCchannel -> [ 0; 7]
 732   //
 733
 734   Int_t iPlate = -1;
 735   if (!(fDDL==-1 || fTRM==-1 || fTDC==-1
 736         || fSector==-1))
 737     iPlate = Equip2VolNplate(GetDDLnumberPerSector(fDDL), fTRM, fTDC);
 738
 739   fPlate = iPlate;
 740
 741 }
 742 //_____________________________________________________________________________
 743
 744 void AliTOFRawStream::SetStrip()
 745 {
 746   //
 747   // Evaluate the TOF strip number per module -> [ 0; 14/18]
 748   // corresponding to the TOF equipment IDs:
 749   //                                  fDDL        -> [ 0;71]
 750   //                                  fTRM        -> [ 3;12]
 751   //                                  fTRMchain   -> [ 0; 1]
 752   //                                  fTDC        -> [ 0;14]
 753   //                                  fTDCchannel -> [ 0; 7]
 754   //
 755
 756   Int_t iStrip = -1;
 757
 758   if (!(fDDL==-1 || fTRM==-1 || fTDC==-1
 759         || fSector==-1 || fPlate==-1))
 760     iStrip = Equip2VolNstrip(GetDDLnumberPerSector(fDDL), fTRM, fTDC);
 761
 762   fStrip = iStrip;
 763
 764 }
 765 //_____________________________________________________________________________
 766
 767 void AliTOFRawStream::SetPadZ()
 768 {
 769   //
 770   // Evaluate the TOF padRow number per strip -> [ 0; 1]
 771   // corresponding to the TOF equipment IDs:
 772   //                                  fDDL        -> [ 0;71]
 773   //                                  fTRM        -> [ 3;12]
 774   //                                  fTRMchain   -> [ 0; 1]
 775   //                                  fTDC        -> [ 0;14]
 776   //                                  fTDCchannel -> [ 0; 7]
 777   //
 778
 779   Int_t iPadZ = -1;
 780
 781   if (!(fDDL==-1 || fTRM==-1 || fTRMchain==-1 || fTDC==-1 || fTDCchannel==-1
 782         || fSector==-1 || fPlate==-1 || fStrip==-1))
 783     {
 784       Int_t iPadAlongTheStrip = Equip2VolNpad(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel);
 785       if (iPadAlongTheStrip!=-1)
 786         iPadZ  = iPadAlongTheStrip%AliTOFGeometry::NpadZ();
 787     }
 788
 789   fPadZ = iPadZ;
 790
 791 }
 792 //_____________________________________________________________________________
 793
 794 void AliTOFRawStream::SetPadX()
 795 {
 796   //
 797   // Evaluate the TOF pad number per strip padRow -> [ 0;47]
 798   // corresponding to the TOF equipment IDs:
 799   //                                  fDDL        -> [ 0;71]
 800   //                                  fTRM        -> [ 3;12]
 801   //                                  fTRMchain   -> [ 0; 1]
 802   //                                  fTDC        -> [ 0;14]
 803   //                                  fTDCchannel -> [ 0; 7]
 804   //
 805
 806   Int_t iPadX = -1;
 807
 808   if (!(fDDL==-1 || fTRM==-1 || fTRMchain==-1 || fTDC==-1 || fTDCchannel==-1
 809         || fSector==-1 || fPlate==-1 || fStrip==-1))
 810     {
 811       Int_t iPadAlongTheStrip = Equip2VolNpad(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel);
 812       if (iPadAlongTheStrip!=-1)
 813         iPadX  = (Int_t)(iPadAlongTheStrip/(Float_t(AliTOFGeometry::NpadZ())));
 814     }
 815
 816   fPadX = iPadX;
 817
 818 }
 819
 820 //----------------------------------------------------------------------------
 821 Int_t AliTOFRawStream::GetField(UInt_t word, Int_t fieldMask, Int_t fieldPosition) const
 822 {
 823   //
 824   //
 825   //
 826
 827   return ((word & fieldMask) >> fieldPosition);
 828 }
 829
 830 //----------------------------------------------------------------------------
 831 Int_t AliTOFRawStream::Equip2VolNplate(Int_t iDDL, Int_t nTRM, Int_t nTDC) const
 832 {
 833   //
 834   // Returns the TOF plate number [0;4]
 835   // corresponding to the TOF equipment ID numbers:
 836   //                          iDDL -> DDL number per sector [0;3]
 837   //                          nTRM -> TRM number [3;12]
 838   //                          nTDC -> TDC number [0;14]
 839   //
 840
 841   Int_t iPlate = -1;
 842   if (iDDL==0) {
 843
 844     if (nTRM>=4 && nTRM<7) {
 845       iPlate = 0;
 846     } else if (nTRM==7) {
 847       if (nTDC<12) iPlate = 0;
 848       else iPlate = 1;
 849     } else if (nTRM>=8 && nTRM<11) {
 850       iPlate = 1;
 851     } else if (nTRM==11) {
 852       if (nTDC<9) iPlate = 1;
 853       else iPlate = 2;
 854     }else if (nTRM==12) {
 855       iPlate = 2;
 856     }
 857
 858   } else if (iDDL==1) {
 859
 860     if (nTRM==3) {
 861       if (nTDC<3) iPlate = 0;
 862     } else if (nTRM>=4 && nTRM<7) {
 863       iPlate = 0;
 864     } else if (nTRM==7) {
 865       if (nTDC<6) iPlate = 1;
 866       else iPlate = 0;
 867     } else if (nTRM>=8 && nTRM<11) {
 868       iPlate = 1;
 869     } else if (nTRM==11) {
 870       if (nTDC<9) iPlate = 2;
 871       else iPlate = 1;
 872     } else if (nTRM==12) {
 873       iPlate = 2;
 874     }
 875
 876   } else if (iDDL==2) {
 877
 878     if (nTRM>=4 && nTRM<7) {
 879       iPlate = 4;
 880     } else if (nTRM==7) {
 881       if (nTDC<12) iPlate = 4;
 882       else iPlate = 3;
 883     } else if (nTRM>=8 && nTRM<11) {
 884       iPlate = 3;
 885     } else if (nTRM==11) {
 886       if (nTDC<9) iPlate = 3;
 887       else iPlate = 2;
 888     }else if (nTRM==12) {
 889       iPlate = 2;
 890     }
 891
 892   }  else if (iDDL==3) {
 893
 894     if (nTRM==3) {
 895       if (nTDC<3) iPlate = 4;
 896     } else if (nTRM>=4 && nTRM<7) {
 897       iPlate = 4;
 898     } else if (nTRM==7) {
 899       if (nTDC<6) iPlate = 3;
 900       else iPlate = 4;
 901     } else if (nTRM>=8 && nTRM<11) {
 902       iPlate = 3;
 903     } else if (nTRM==11) {
 904       if (nTDC<9) iPlate = 2;
 905       else iPlate = 3;
 906     } else if (nTRM==12) {
 907       iPlate = 2;
 908     }
 909
 910   }
 911
 912   return iPlate;
 913
 914 }
 915
 916 //----------------------------------------------------------------------------
 917 Int_t AliTOFRawStream::Equip2VolNstrip(Int_t iDDL, Int_t nTRM, Int_t nTDC) const
 918 {
 919   //
 920   // Returns the TOF strip number per module:
 921   //                                [0;14], in the central plates,
 922   //                                [0;18], in the intermediate and external plates
 923   // corresponding to the TOF equipment ID numbers:
 924   //                                iDDL -> DDL number per sector [0;3]
 925   //                                nTRM -> TRM number [3;12]
 926   //                                nTDC -> TDC number [0;14]
 927   //
 928
 929   Int_t iStrip = -1;
 930
 931   if (iDDL==0) {
 932
 933     if (nTRM== 4) iStrip =  (Int_t)(nTDC/3.);
 934     else if (nTRM== 5) iStrip =  5 + (Int_t)(nTDC/3.);
 935     else if (nTRM== 6) iStrip = 10 + (Int_t)(nTDC/3.);
 936     else if (nTRM== 7) {
 937       if (nTDC<12) iStrip =  15 + (Int_t)(nTDC/3.);
 938       else iStrip = (Int_t)(nTDC/3.) -  4;
 939     }
 940     else if (nTRM== 8) iStrip =  1 + (Int_t)(nTDC/3.);
 941     else if (nTRM== 9) iStrip =  6 + (Int_t)(nTDC/3.);
 942     else if (nTRM==10) iStrip = 11 + (Int_t)(nTDC/3.);
 943     else if (nTRM==11) {
 944       if (nTDC<9) iStrip = 16 + (Int_t)(nTDC/3.);
 945       else iStrip = (Int_t)(nTDC/3.) -  3;
 946     }
 947     else if (nTRM==12) iStrip =  2 + (Int_t)(nTDC/3.);
 948
 949   } else if (iDDL==1) {
 950
 951     if (nTRM==3 && nTDC<3) iStrip = (Int_t)(nTDC/3.);
 952     else if (nTRM== 4) iStrip =  5 - (Int_t)(nTDC/3.);
 953     else if (nTRM== 5) iStrip = 10 - (Int_t)(nTDC/3.);
 954     else if (nTRM== 6) iStrip = 15 - (Int_t)(nTDC/3.);
 955     else if (nTRM== 7) {
 956       if (nTDC<6) iStrip =  1 - (Int_t)(nTDC/3.);
 957       else iStrip = 20 - (Int_t)(nTDC/3.);
 958     }
 959     else if (nTRM== 8) iStrip =  6 - (Int_t)(nTDC/3.);
 960     else if (nTRM== 9) iStrip = 11 - (Int_t)(nTDC/3.);
 961     else if (nTRM==10) iStrip = 16 - (Int_t)(nTDC/3.);
 962     else if (nTRM==11) {
 963       if (nTDC<9) iStrip =  2 - (Int_t)(nTDC/3.);
 964       else iStrip = 21 - (Int_t)(nTDC/3.);
 965     }
 966     else if (nTRM==12) iStrip =  7 - (Int_t)(nTDC/3.);
 967
 968   } else if (iDDL==2) {
 969
 970     if (nTRM== 4) iStrip =  18 - (Int_t)(nTDC/3.);
 971     else if (nTRM== 5) iStrip = 18 - ( 5 + (Int_t)(nTDC/3.));
 972     else if (nTRM== 6) iStrip = 18 - (10 + (Int_t)(nTDC/3.));
 973     else if (nTRM== 7) {
 974       if (nTDC<12) iStrip =  18 - (15 + (Int_t)(nTDC/3.));
 975       else iStrip = 18 - ((Int_t)(nTDC/3.) -  4);
 976     }
 977     else if (nTRM== 8) iStrip = 18 - ( 1 + (Int_t)(nTDC/3.));
 978     else if (nTRM== 9) iStrip = 18 - ( 6 + (Int_t)(nTDC/3.));
 979     else if (nTRM==10) iStrip = 18 - (11 + (Int_t)(nTDC/3.));
 980     else if (nTRM==11) {
 981       if (nTDC<9) iStrip = 18 - (16 + (Int_t)(nTDC/3.));
 982       else iStrip = 14 - ((Int_t)(nTDC/3.) -  3);
 983     }
 984     else if (nTRM==12) iStrip = 14 - ( 2 + (Int_t)(nTDC/3.));
 985
 986   } else if (iDDL==3) {
 987
 988     if (nTRM==3 && nTDC<3) iStrip = 18 - (Int_t)(nTDC/3.);
 989     else if (nTRM== 4) iStrip = 18 - ( 5 - (Int_t)(nTDC/3.));
 990     else if (nTRM== 5) iStrip = 18 - (10 - (Int_t)(nTDC/3.));
 991     else if (nTRM== 6) iStrip = 18 - (15 - (Int_t)(nTDC/3.));
 992     else if (nTRM== 7) {
 993       if (nTDC<6) iStrip =  18 - (1 - (Int_t)(nTDC/3.));
 994       else iStrip = 18 - (20 - (Int_t)(nTDC/3.));
 995     }
 996     else if (nTRM== 8) iStrip = 18 - ( 6 - (Int_t)(nTDC/3.));
 997     else if (nTRM== 9) iStrip = 18 - (11 - (Int_t)(nTDC/3.));
 998     else if (nTRM==10) iStrip = 18 - (16 - (Int_t)(nTDC/3.));
 999     else if (nTRM==11) {
1000       if (nTDC<9) iStrip = 14 - ( 2 - (Int_t)(nTDC/3.));
1001       else iStrip = 18 - (21 - (Int_t)(nTDC/3.));
1002     }
1003     else if (nTRM==12) iStrip = 14 - ( 7 - (Int_t)(nTDC/3.));
1004
1005   }
1006
1007   return iStrip;
1008
1009 }
1010
1011 //----------------------------------------------------------------------------
1012 Int_t AliTOFRawStream::Equip2VolNpad(Int_t iDDL, Int_t iChain, Int_t nTDC,
1013                                 Int_t iCH) const
1014 {
1015   //
1016   // Returns the TOF pad number per strip [0;95]
1017   // corresponding to the TOF equipment ID numbers:
1018   //                          iDDL -> DDL number per sector [0;3]
1019   //                        iChain -> TRM chain number [0;1]
1020   //                          nTDC -> TDC number [0;14]
1021   //                           iCH -> TDC channel number [0;7]
1022   //
1023
1024   Int_t iPadAlongTheStrip = -1;
1025
1026   Int_t iTDClocal = nTDC%3 + (1-iChain)*3;
1027
1028   if (iDDL==0 || iDDL==3) iTDClocal = 5 - iTDClocal;
1029   else if (iDDL==1 || iDDL==2) iTDClocal = 6 + (5 - iTDClocal);
1030
1031   Int_t iCHlocal = iCH;
1032   if (iDDL==0 || iDDL==3) iCHlocal = 7 - iCH;
1033
1034   iPadAlongTheStrip = iTDClocal*AliTOFGeometry::NCh() + iCHlocal;
1035
1036   if (((iDDL==1 || iDDL==2) && iPadAlongTheStrip< AliTOFGeometry::NpadX()) ||
1037       ((iDDL==0 || iDDL==3) && iPadAlongTheStrip>=AliTOFGeometry::NpadX()))
1038     AliError("Problems with the padX number!");
1039
1040   return iPadAlongTheStrip;
1041
1042 }
1043
1044 //----------------------------------------------------------------------------
1045 Int_t AliTOFRawStream::GetSectorNumber(Int_t nDDL) const
1046 {
1047   //
1048   // Returns the sector number [0;17]
1049   // corresponing to the assigned DRM/DDL number [0;71]
1050   //
1051
1052   Int_t iSector = Int_t((Float_t)(nDDL)/AliTOFGeometry::NDDL());
1053
1054   return iSector;
1055
1056 }
1057 //----------------------------------------------------------------------------
1058 Int_t AliTOFRawStream::GetDDLnumberPerSector(Int_t nDDL) const
1059 {
1060   //
1061   // Return the DRM/DDL number per sector [0;3]
1062   // corresponing to the assigned DRM/DDL number [0;71]
1063   //
1064
1065   Int_t iDDL = nDDL%AliTOFGeometry::NDDL();
1066
1067   return iDDL;
1068
1069 }
1070
1071 //----------------------------------------------------------------------------
1072 void AliTOFRawStream::EquipmentId2VolumeId(AliTOFHitData *hitData, Int_t *volume) const
1073 {
1074   EquipmentId2VolumeId(hitData->GetDDLID(),hitData->GetSlotID(),hitData->GetChain(),hitData->GetTDC(),hitData->GetChan(),volume);
1075 }
1076 //----------------------------------------------------------------------------
1077 void AliTOFRawStream::EquipmentId2VolumeId(Int_t nDDL, Int_t nTRM, Int_t iChain,
1078                                         Int_t nTDC, Int_t iCH,
1079                                         Int_t *volume) const
1080 {
1081   //
1082   // To convert:
1083   //            nDDL   (variable in [0;71]) -> number of the DDL file
1084   //            nTRM   (variable in [3;12]) -> number of the TRM slot
1085   //            iChain (variable in [0; 1]) -> number of the TRM chain
1086   //            nTDC   (variable in [0;14]) -> number of the TDC
1087   //            iCH    (variable in [0; 7]) -> number of the TDC channel
1088   //
1089   // in:
1090   //      sector number, i.e. volume[0] (variable in [0,17])
1091   //      plate  number, i.e. volume[1] (variable in [0, 5])
1092   //      strip  number, i.e. volume[2] (variable in [0,14/18])
1093   //      padX   number, i.e. volume[3] (variable in [0,47])
1094   //      padZ   number, i.e. volume[4] (variable in [0, 1])
1095   //
1096
1097   Int_t iDDL = GetDDLnumberPerSector(nDDL);
1098
1099   Int_t iSector = GetSectorNumber(nDDL);
1100
1101   Int_t iPlate = Equip2VolNplate(iDDL, nTRM, nTDC);
1102   if (iPlate==-1) AliError("Problems with the plate number!");
1103
1104   Int_t iStrip = Equip2VolNstrip(iDDL, nTRM, nTDC);
1105   if (iStrip==-1) AliError("Problems with the strip number!");
1106
1107   Int_t iPadAlongTheStrip  = Equip2VolNpad(iDDL, iChain, nTDC, iCH);
1108   if (iPadAlongTheStrip==-1)
1109     AliError("Problems with the pad number along the strip!");
1110
1111   Int_t iPadX  = (Int_t)(iPadAlongTheStrip/(Float_t(AliTOFGeometry::NpadZ())));
1112   Int_t iPadZ  = iPadAlongTheStrip%AliTOFGeometry::NpadZ();
1113
1114   volume[0] = iSector;
1115   volume[1] = iPlate;
1116   volume[2] = iStrip;
1117   volume[3] = iPadX;
1118   volume[4] = iPadZ;
1119
1120 }
1121 //_____________________________________________________________________________
1122
1123 Int_t AliTOFRawStream::GetIndex(Int_t *detId)
1124 {
1125   //Retrieve calibration channel index
1126   const Int_t kSectors = fTOFGeometry->NSectors();
1127   const Int_t kPlates = fTOFGeometry->NPlates();
1128   const Int_t kStripA = fTOFGeometry->NStripA();
1129   const Int_t kStripB = fTOFGeometry->NStripB();
1130   const Int_t kStripC = fTOFGeometry->NStripC();
1131   const Int_t kPadX = fTOFGeometry->NpadX();
1132   const Int_t kPadZ = fTOFGeometry->NpadZ();
1133
1134
1135   Int_t isector = detId[0];
1136   if (isector >= kSectors)
1137     AliError(Form("Wrong sector number in TOF (%d) !",isector));
1138   Int_t iplate = detId[1];
1139   if (iplate >= kPlates)
1140     AliError(Form("Wrong plate number in TOF (%d) !",iplate));
1141   Int_t istrip = detId[2];
1142   Int_t ipadz = detId[3];
1143   Int_t ipadx = detId[4];
1144   Int_t stripOffset = 0;
1145   switch (iplate) {
1146   case 0:
1147     stripOffset = 0;
1148     break;
1149   case 1:
1150     stripOffset = kStripC;
1151     break;
1152   case 2:
1153     stripOffset = kStripC+kStripB;
1154     break;
1155   case 3:
1156     stripOffset = kStripC+kStripB+kStripA;
1157     break;
1158   case 4:
1159     stripOffset = kStripC+kStripB+kStripA+kStripB;
1160     break;
1161   default:
1162     AliError(Form("Wrong plate number in TOF (%d) !",iplate));
1163     break;
1164   };
1165
1166   Int_t idet = ((2*(kStripC+kStripB)+kStripA)*kPadZ*kPadX)*isector +
1167                (stripOffset*kPadZ*kPadX)+
1168                (kPadZ*kPadX)*istrip+
1169                (kPadX)*ipadz+
1170                 ipadx;
1171   return idet;
1172 }
1173 //-----------------------------------------------------------------------------
1174 Bool_t AliTOFRawStream::DecodeDDL(Int_t DDLMin, Int_t DDLMax, Int_t verbose = 0){
1175   //check and fix valid DDL range
1176   if (DDLMin < 0){
1177     DDLMin = 0;
1178     AliError("Wrong DDL range: setting first DDL ID to 0");
1179   }
1180   if (DDLMax > 71){
1181     DDLMax = 71;
1182     AliError("Wrong DDL range: setting last DDL ID to 71");
1183   }
1184
1185   //select required DDLs
1186   fRawReader->Select("TOF", DDLMin, DDLMax);
1187
1188   if (verbose)
1189     AliInfo(Form("Selected TOF DDL range: %d-%d", DDLMin, DDLMax));
1190
1191   return(Decode(verbose));
1192 }
1193 //-----------------------------------------------------------------------------
1194 Bool_t AliTOFRawStream::Decode(Int_t verbose = 0){
1195   Int_t currentEquipment;
1196   Int_t currentDDL;
1197
1198   //pointers
1199   UChar_t *data = 0x0;
1200
1201   //loop and read DDL headers
1202   while(fRawReader->ReadHeader()){
1203
1204     //memory leak prevention (actually data should be always 0x0 here)
1205     if (data != 0x0)
1206       delete [] data;
1207
1208     //get equipment infos
1209     currentEquipment = fRawReader->GetEquipmentId();
1210     currentDDL = fRawReader->GetDDLID();
1211     const Int_t kDataSize = fRawReader->GetDataSize();
1212     const Int_t kDataWords = kDataSize / 4;
1213     data = new UChar_t[kDataSize];
1214
1215     if (verbose)
1216       AliInfo(Form("Found equipment # %d header (DDL # %d): %d bytes (%d words)", currentEquipment, currentDDL, kDataSize, kDataWords));
1217
1218     if (verbose)
1219       AliInfo(Form("Reading equipment #%d (DDL # %d) data...", currentEquipment, currentDDL));
1220
1221     //read equipment payload
1222     if (!fRawReader->ReadNext(data, kDataSize))
1223       {
1224         if (verbose)
1225           AliError("Error while reading DDL data. Go to next equipment");
1226         delete [] data;
1227         data = 0x0;
1228         continue;
1229       }
1230
1231     if (verbose)
1232       AliInfo(Form("Equipment # %d (DDL # %d) data has been readed", currentEquipment, currentDDL));
1233
1234
1235     //set up the decoder
1236     fDecoder->SetVerbose(verbose);
1237     fDecoder->SetDataBuffer(fDataBuffer[currentDDL]);
1238     fDecoder->SetPackedDataBuffer(fPackedDataBuffer[currentDDL]);
1239
1240     //start decoding
1241     if (fDecoder->Decode((UInt_t *)data, kDataWords) == kTRUE)
1242       AliError(Form("Error while decoding DDL # %d: decoder returned with errors", currentDDL));
1243
1244     delete [] data;
1245     data = 0x0;
1246   }
1247
1248   //reset reader
1249   fRawReader->Reset();
1250
1251   if (verbose)
1252     AliInfo("All done");
1253
1254   return kFALSE;
1255
1256 }
1257 //---------------------------------------------------------------------------
1258 void
1259 AliTOFRawStream::ResetBuffers()
1260 {
1261   //
1262   // To reset the buffers
1263   //
1264
1265   for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls("TOF"); iDDL++){
1266     ResetDataBuffer(iDDL);
1267     ResetPackedDataBuffer(iDDL);
1268   }
1269 }
1270
1271 //---------------------------------------------------------------------------
1272 Bool_t
1273 AliTOFRawStream::LoadRawDataBuffers(Int_t indexDDL, Int_t verbose)
1274 {
1275   //
1276   // To load the buffers
1277   //
1278
1279   fTOFrawData->Clear();
1280   fPackedDigits = 0;
1281
1282   if (verbose > 0)
1283     AliInfo(Form("Decoding raw data for DDL # %d ...", indexDDL));
1284
1285   if (DecodeDDL(indexDDL, indexDDL, verbose) != 0){ //decode DDL
1286     AliError(Form("Error while decoding DDL # %d", indexDDL));
1287     return kTRUE;
1288   }
1289
1290   if (verbose > 0)
1291     AliInfo(Form("Done. %d packed %s been found.", fPackedDataBuffer[indexDDL]->GetEntries(), fPackedDataBuffer[indexDDL]->GetEntries() > 1 ? "hits have" : "hit has"));
1292
1293   AliTOFHitData *hitData; //hit data pointer
1294
1295   if (verbose > 0)
1296     AliInfo("Filling TClonesArray ...");
1297
1298   //loop over DDL packed hits
1299   for (Int_t iHit = 0; iHit < fPackedDataBuffer[indexDDL]->GetEntries(); iHit++){
1300     hitData = fPackedDataBuffer[indexDDL]->GetHit(iHit); //get hit data
1301     Int_t   hitACQ = hitData->GetACQ();
1302     Int_t   hitPS = hitData->GetPS();
1303     Int_t   hitSlotID = hitData->GetSlotID();
1304     Int_t   hitChain = hitData->GetChain();
1305     Int_t   hitTDC = hitData->GetTDC();
1306     Int_t   hitChan = hitData->GetChan();
1307     Int_t   hitTimeBin = hitData->GetTimeBin();
1308     Int_t   hitTOTBin = hitData->GetTOTBin();
1309
1310     Int_t hitLeading = -1;
1311     Int_t hitTrailing = -1;
1312     Int_t hitError = -1;
1313
1314     TClonesArray &arrayTofRawData =  *fTOFrawData;
1315     new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(hitSlotID, hitChain, hitTDC, hitChan, hitTimeBin, hitTOTBin, hitLeading, hitTrailing, hitPS, hitACQ, hitError);
1316   }
1317
1318   if (verbose > 0)
1319     AliInfo("Done.");
1320
1321   if (verbose > 0)
1322     AliInfo("Resetting buffers ...");
1323
1324   fDataBuffer[indexDDL]->Reset();
1325   fPackedDataBuffer[indexDDL]->Reset();
1326
1327   if (verbose > 0)
1328     AliInfo("Done.");
1329
1330   return kFALSE;
1331 }
1332