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