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
  19 Added lookup tables for
  20          TRM number 3 in the left crates (TOF OR signals)
  21          and detector elements (A.Silenzi)
  22
  23 Revision 1.19.1  2008/09/19  preghenella
  24   Decode method updated:
  25   it reads the CDH from the rawReader and sends it to the decoder;
  26  LoadRawDataBuffers modified:
  27      it corrects tof hit infos per ddlBC and deltaBC offsets
  28      (in case of the static member fgApplyBCCorrections
  29       has been setted to kTRUE);
  30  Added static member fgApplyBCCorrections (kTRUE by default)
  31  and the related static method ApplyBCCorrections;
  32
  33 Revision 1.19  2007/05/18 13:07:53  decaro
  34 Error messages stored in the global raw-reader error log (Cvetan, Chiara)
  35
  36 Revision 1.18  2007/05/08 11:53:29  arcelli
  37 Improved class flexibility for further use (R.Preghenella)
  38
  39 Revision 1.17  2007/05/03 08:53:50  decaro
  40 Coding convention: RS3 violation -> suppression
  41
  42 Revision 1.16  2007/05/03 08:22:22  decaro
  43 Coding convention: RN17 violation -> suppression
  44
  45 Revision 1.15  2007/04/30 15:22:06  arcelli
  46 Change TOF digit Time, Tot etc to int type
  47
  48 Revision 1.14  2007/04/27 11:11:53  arcelli
  49 updates for the new decoder
  50
  51 Revision 1.13  2007/03/16 11:46:35  decaro
  52 Coding convention: RN17 rule violation -> suppression
  53
  54 Revision 1.12  2007/02/22 09:43:45  decaro
  55 Added AliTOFRawStream::GetIndex method for online calibration (C.Zampolli)
  56
  57 Revision 1.11  2007/02/20 15:57:00  decaro
  58 Raw data update: to read the TOF raw data defined in UNPACKED mode
  59
  60 Revision 1.10  2006/12/15 14:01:38  cvetan
  61 Memory leak fixed
  62
  63 Revision 1.9  2006/10/13 11:22:27  arcelli
  64 remove warnings due to uninitialized AliTOFtdcDigit data members
  65
  66 Revision 1.8  2006/08/22 13:30:17  arcelli
  67 removal of effective c++ warnings (C.Zampolli)
  68
  69 Revision 1.7  2006/08/10 14:46:54  decaro
  70 TOF raw data format: updated version
  71
  72 Revision 1.6.1  2006/06/28 A. De Caro, R. Preghenella:
  73         Update TOF raw data format
  74         according to the final version
  75         (see the ALICE internal note in preparation
  76          'ALICE TOF raw data format')
  77         Added the methods for the correspoonding numbering
  78          between the equipment IDs and the volume IDs:
  79            Equip2VolNPlate(...)
  80            Equip2VolNStrip(...)
  81            Equip2VolNPad(...)
  82
  83 Revision 0.02  2005/07/28 A. De Caro:
  84         Update format TOF raw data
  85                (temporary solution)
  86         Correction of few wrong corrispondences
  87                between 'software' and 'hardware' numberings
  88
  89 Revision 0.01  2005/07/22 A. De Caro
  90         Implement methods Next()
  91                           GetSector(),
  92                           GetPlate(),
  93                           GetStrip(),
  94                           GetPadZ(),
  95                           GetPadX()
  96 */
  97
  98 ////////////////////////////////////////////////////////////////////////
  99 //                                                                    //
 100 //     This class provides access to TOF raw data in DDL files.       //
 101 //                                                                    //
 102 //      It loops over all TOF raw data given by the AliRawReader.     //
 103 //                                                                    //
 104 ////////////////////////////////////////////////////////////////////////
 105
 106
 107 #include "Riostream.h"
 108
 109 #include "TClonesArray.h"
 110 #include "TStopwatch.h"
 111
 112 #include "AliDAQ.h"
 113 #include "AliLog.h"
 114 #include "AliRawReader.h"
 115
 116 #include "AliTOFGeometry.h"
 117 #include "AliTOFrawData.h"
 118 #include "AliTOFRawMap.h"
 119 #include "AliTOFRawStream.h"
 120 #include "AliTOFdigit.h"
 121 #include "AliTOFSDigit.h"
 122 //#include "AliTOFCableLengthMap.h"
 123
 124 #include "AliTOFHitData.h"
 125
 126 #include "AliRawEventHeaderBase.h"
 127 #include "AliRawDataHeader.h"
 128
 129 #include "AliTOFDecoderV2.h"
 130 #include "AliTOFTDCHit.h"
 131 #include "AliTOFDecoderSummaryData.h"
 132 #include "AliTOFDRMSummaryData.h"
 133 #include "AliTOFLTMSummaryData.h"
 134 #include "AliTOFTRMSummaryData.h"
 135 #include "AliTOFChainSummaryData.h"
 136 #include "AliTOFTDCHitBuffer.h"
 137 #include "AliTOFTDCErrorBuffer.h"
 138
 139 ClassImp(AliTOFRawStream)
 140
 141 const Int_t AliTOFRawStream::fgkddlBCshift[72] =
 142 {
 143   0, 0, 0, 0,
 144   0, 0, 0, 0,
 145   0, 0, 0, 0,
 146   0, 0, 0, 0,
 147   0, 0, 0, 0,
 148   0, 0, 0, 0,
 149   0, 0, 0, 0,
 150   0, 0, 0, 0,
 151   0, 0, 0, 0,
 152   0, 0, 0, 0,
 153   0, 0, 0, 0,
 154   0, 0, 0, 0,
 155   0, 0, 0, 0,
 156   0, 0, 0, 0,
 157   0, 0, 0, 0,
 158   0, 0, 0, 0,
 159   0, 0, 0, 0,
 160   0, 0, 0, 0
 161 };
 162
 163 const Int_t AliTOFRawStream::fgkStrip0MapCrate0[]=
 164   {1,3,5,7,9,11,13,15,17,0,2,4,6,8,10,12,14,16,18,1,3,5,7,-1};
 165 const Int_t AliTOFRawStream::fgkStrip1MapCrate0[]=
 166   {0,2,4,6,8,10,12,14,16,18,1,3,5,7,9,11,13,15,17,0,2,4,6,-1};
 167 const Int_t AliTOFRawStream::fgkStrip0MapCrate1[]=
 168   {1,3,5,7,9,11,13,15,17,0,2,4,6,8,10,12,14,16,18,1,3,5,7,-1};
 169 const Int_t AliTOFRawStream::fgkStrip1MapCrate1[]=
 170   {0,2,4,6,8,10,12,14,16,18,1,3,5,7,9,11,13,15,17,0,2,4,6,-1};
 171 const Int_t AliTOFRawStream::fgkStrip0MapCrate2[]=
 172   {17,15,13,11, 9,7,5,3,1,18,16,14,12,10,8,6,4,2, 0,13,11, 9,7,-1};
 173 const Int_t AliTOFRawStream::fgkStrip1MapCrate2[]=
 174   {18,16,14,12,10,8,6,4,2, 0,17,15,13,11,9,7,5,3, 1,14,12,10,8,-1};
 175 const Int_t AliTOFRawStream::fgkStrip0MapCrate3[]=
 176   {17,15,13,11, 9,7,5,3,1,18,16,14,12,10,8,6,4,2, 0,13,11, 9,7,-1};
 177 const Int_t AliTOFRawStream::fgkStrip1MapCrate3[]=
 178   {18,16,14,12,10,8,6,4,2, 0,17,15,13,11,9,7,5,3, 1,14,12,10,8,-1};
 179
 180
 181 const Int_t AliTOFRawStream::fgkModule0MapCrate0[]=
 182   {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2,2,2,2,-1};
 183 const Int_t AliTOFRawStream::fgkModule1MapCrate0[]=
 184   {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2,2,2,2,-1};
 185 const Int_t AliTOFRawStream::fgkModule0MapCrate1[]=
 186   {0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2,2,2,2,-1};
 187 const Int_t AliTOFRawStream::fgkModule1MapCrate1[]=
 188   {0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2,2,2,2,-1};
 189
 190 const Int_t AliTOFRawStream::fgkModule0MapCrate2[]=
 191   {4,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,3,2,2,2,2,-1};
 192 const Int_t AliTOFRawStream::fgkModule1MapCrate2[]=
 193   {4,4,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,2,2,2,2,-1};
 194 const Int_t AliTOFRawStream::fgkModule0MapCrate3[]=
 195   {4,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,3,2,2,2,2,-1};
 196 const Int_t AliTOFRawStream::fgkModule1MapCrate3[]=
 197   {4,4,4,4,4,4,4,4,4,4,3,3,3,3,3,3,3,3,3,2,2,2,2,-1};
 198
 199 const Int_t AliTOFRawStream::fgkChannelMap0[5][19]=
 200   {{0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9},
 201    {9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18},
 202    {19,19,20,20,21,21,22,22,22,21,21,20,20,19,19,-1,-1,-1,-1},
 203    {18,18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9},
 204    {9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,1,1,0,0}
 205   };
 206
 207 const Int_t AliTOFRawStream::fgkChainMap0[5][19]=
 208   {{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
 209    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
 210    {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,-1,-1,-1,-1},
 211    {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 212    {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
 213   };
 214
 215 const Int_t AliTOFRawStream::fgkChannelMap24[5][19]=
 216   {{0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9},
 217    {9,10,10,11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18},
 218    {19,19,20,20,21,21,22,22,22,21,21,20,20,19,19,-1,-1,-1,-1},
 219    {18,18,17,17,16,16,15,15,14,14,13,13,12,12,11,11,10,10,9},
 220    {9,8,8,7,7,6,6,5,5,4,4,3,3,2,2,1,1,0,0}
 221   };
 222
 223 const Int_t AliTOFRawStream::fgkChainMap24[5][19]=
 224   {{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 225    {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
 226    {1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,-1,-1,-1,-1},
 227    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
 228    {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
 229   };
 230
 231 Bool_t AliTOFRawStream::fgApplyBCCorrections = kTRUE;
 232 //_____________________________________________________________________________
 233 AliTOFRawStream::AliTOFRawStream(AliRawReader* rawReader):
 234   fRawReader(rawReader),
 235   fTOFrawData(new TClonesArray("AliTOFrawData",1000)),
 236   fDecoder(new AliTOFDecoder()),
 237   fDecoderV2(new AliTOFDecoderV2()),
 238   fDDL(-1),
 239   fTRM(-1),
 240   fTRMchain(-1),
 241   fTDC(-1),
 242   fTDCchannel(-1),
 243   fTime(-1),
 244   fToT(-1),
 245   fLeadingEdge(-1),
 246   fTrailingEdge(-1),
 247   fErrorFlag(-1),
 248   fSector(-1),
 249   fPlate(-1),
 250   fStrip(-1),
 251   fPadX(-1),
 252   fPadZ(-1),
 253   fPackedDigits(0),
 254   fWordType(-1),
 255   fSlotID(-1),
 256   fACQ(-1),
 257   fPSbit(-1),
 258   fTDCerrorFlag(-1),
 259   fInsideDRM(kFALSE),
 260   fInsideTRM(kFALSE),
 261   fInsideLTM(kFALSE),
 262   fInsideTRMchain0(kFALSE),
 263   fInsideTRMchain1(kFALSE),
 264   //fDataBuffer(),
 265   //fPackedDataBuffer(),
 266   fLocalEventCounterDRM(-1),
 267   fLocalEventCounterLTM(-1),
 268   //fLocalEventCounterTRM(),
 269   //fLocalEventCounterChain(),
 270   //fChainBunchID(),
 271   //fCableLengthMap(new AliTOFCableLengthMap()),
 272   fEventID(0),
 273   fNewDecoderVersion(0)
 274 {
 275   //
 276   // create an object to read TOF raw digits
 277   //
 278
 279   for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
 280     ResetDataBuffer(i);
 281     ResetPackedDataBuffer(i);
 282   }
 283
 284   //fTOFrawData = new TClonesArray("AliTOFrawData",1000);
 285   fTOFrawData->SetOwner();
 286
 287   fRawReader->Reset();
 288   fRawReader->Select("TOF");
 289
 290   for (Int_t jj=0;jj<13;jj++) {
 291     fLocalEventCounterTRM[jj] = -1;
 292     for (Int_t ii=0;ii<2;ii++) {
 293       fLocalEventCounterChain[jj][ii] = -1;
 294       fChainBunchID[jj][ii] = -1;
 295     }
 296   }
 297
 298 }
 299
 300 //_____________________________________________________________________________
 301 AliTOFRawStream::AliTOFRawStream():
 302   fRawReader(0x0),
 303   fTOFrawData(new TClonesArray("AliTOFrawData",1000)),
 304   fDecoder(new AliTOFDecoder()),
 305   fDecoderV2(new AliTOFDecoderV2()),
 306   fDDL(-1),
 307   fTRM(-1),
 308   fTRMchain(-1),
 309   fTDC(-1),
 310   fTDCchannel(-1),
 311   fTime(-1),
 312   fToT(-1),
 313   fLeadingEdge(-1),
 314   fTrailingEdge(-1),
 315   fErrorFlag(-1),
 316   fSector(-1),
 317   fPlate(-1),
 318   fStrip(-1),
 319   fPadX(-1),
 320   fPadZ(-1),
 321   fPackedDigits(0),
 322   fWordType(-1),
 323   fSlotID(-1),
 324   fACQ(-1),
 325   fPSbit(-1),
 326   fTDCerrorFlag(-1),
 327   fInsideDRM(kFALSE),
 328   fInsideTRM(kFALSE),
 329   fInsideLTM(kFALSE),
 330   fInsideTRMchain0(kFALSE),
 331   fInsideTRMchain1(kFALSE),
 332   //fDataBuffer(),
 333   //fPackedDataBuffer(),
 334   fLocalEventCounterDRM(-1),
 335   fLocalEventCounterLTM(-1),
 336   //fLocalEventCounterTRM(),
 337   //fLocalEventCounterChain(),
 338   //fChainBunchID(),
 339   //fCableLengthMap(new AliTOFCableLengthMap()),
 340   fEventID(0),
 341   fNewDecoderVersion(0)
 342 {
 343   //
 344   // default ctr
 345   //
 346   for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
 347     ResetDataBuffer(i);
 348     ResetPackedDataBuffer(i);
 349   }
 350
 351   //fTOFrawData = new TClonesArray("AliTOFrawData",1000);
 352   fTOFrawData->SetOwner();
 353
 354   for (Int_t j=0;j<13;j++){
 355     fLocalEventCounterTRM[j] = -1;
 356     for (Int_t k=0;k<2;k++){
 357       fLocalEventCounterChain[j][k] = -1;
 358       fChainBunchID[j][k] = -1;
 359     }
 360   }
 361
 362 }
 363
 364 //_____________________________________________________________________________
 365 AliTOFRawStream::AliTOFRawStream(const AliTOFRawStream& stream) :
 366   TObject(stream),
 367   fRawReader(stream.fRawReader),
 368   fTOFrawData(stream.fTOFrawData),
 369   fDecoder(new AliTOFDecoder()),
 370   fDecoderV2(new AliTOFDecoderV2()),
 371   fDDL(stream.fDDL),
 372   fTRM(stream.fTRM),
 373   fTRMchain(stream.fTRMchain),
 374   fTDC(stream.fTDC),
 375   fTDCchannel(stream.fTDCchannel),
 376   fTime(stream.fTime),
 377   fToT(-stream.fToT),
 378   fLeadingEdge(stream.fLeadingEdge),
 379   fTrailingEdge(stream.fTrailingEdge),
 380   fErrorFlag(stream.fErrorFlag),
 381   fSector(stream.fSector),
 382   fPlate(stream.fPlate),
 383   fStrip(stream.fStrip),
 384   fPadX(stream.fPadX),
 385   fPadZ(stream.fPadZ),
 386   fPackedDigits(stream.fPackedDigits),
 387   fWordType(stream.fWordType),
 388   fSlotID(stream.fSlotID),
 389   fACQ(stream.fACQ),
 390   fPSbit(stream.fPSbit),
 391   fTDCerrorFlag(stream.fTDCerrorFlag),
 392   fInsideDRM(stream.fInsideDRM),
 393   fInsideTRM(stream.fInsideTRM),
 394   fInsideLTM(stream.fInsideLTM),
 395   fInsideTRMchain0(stream.fInsideTRMchain0),
 396   fInsideTRMchain1(stream.fInsideTRMchain1),
 397   //fDataBuffer(),
 398   //fPackedDataBuffer(),
 399   fLocalEventCounterDRM(stream.fLocalEventCounterDRM),
 400   fLocalEventCounterLTM(stream.fLocalEventCounterLTM),
 401   //fLocalEventCounterTRM(),
 402   //fLocalEventCounterChain(),
 403   //fChainBunchID(),
 404   //fCableLengthMap(stream.fCableLengthMap),
 405   fEventID(stream.fEventID),
 406   fNewDecoderVersion(stream.fNewDecoderVersion)
 407 {
 408   //
 409   // copy constructor
 410   //
 411
 412   for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
 413     fDataBuffer[i] = stream.fDataBuffer[i];
 414     fPackedDataBuffer[i] = stream.fPackedDataBuffer[i];
 415   }
 416
 417   fTOFrawData = new TClonesArray(*stream.fTOFrawData);
 418
 419   for (Int_t j=0;j<13;j++){
 420     fLocalEventCounterTRM[j] = stream.fLocalEventCounterTRM[j];
 421     for (Int_t k=0;k<2;k++){
 422       fLocalEventCounterChain[j][k] = stream.fLocalEventCounterChain[j][k];
 423       fChainBunchID[j][k] = stream.fChainBunchID[j][k];
 424     }
 425   }
 426
 427 }
 428
 429 //_____________________________________________________________________________
 430 AliTOFRawStream& AliTOFRawStream::operator = (const AliTOFRawStream& stream)
 431 {
 432   //
 433   // assignment operator
 434   //
 435
 436   if (this == &stream)
 437     return *this;
 438
 439   TObject::operator=(stream);
 440
 441   fRawReader = stream.fRawReader;
 442
 443   fTOFrawData = stream.fTOFrawData;
 444
 445   fDDL = stream.fDDL;
 446   fTRM = stream.fTRM;
 447   fTRMchain = stream.fTRMchain;
 448   fTDC = stream.fTDC;
 449   fTDCchannel = stream.fTDCchannel;
 450   fTime = stream.fTime;
 451   fToT = stream.fToT;
 452   fLeadingEdge = stream.fLeadingEdge;
 453   fTrailingEdge = stream.fTrailingEdge;
 454   fErrorFlag = stream.fErrorFlag;
 455
 456   fSector = stream.fSector;
 457   fPlate = stream.fPlate;
 458   fStrip = stream.fStrip;
 459   fPadX = stream.fPadX;
 460   fPadZ = stream.fPadZ;
 461
 462   fPackedDigits = stream.fPackedDigits;
 463
 464   fWordType = stream.fWordType;
 465   fSlotID = stream.fSlotID;
 466   fACQ = stream.fACQ;
 467   fPSbit = stream.fPSbit;
 468   fTDCerrorFlag = stream.fTDCerrorFlag;
 469   fInsideDRM = stream.fInsideDRM;
 470   fInsideTRM = stream.fInsideTRM;
 471   fInsideLTM = stream.fInsideLTM;
 472   fInsideTRMchain0 = stream.fInsideTRMchain0;
 473   fInsideTRMchain1 = stream.fInsideTRMchain1;
 474
 475   for (Int_t i=0;i<AliDAQ::NumberOfDdls("TOF");i++){
 476     fDataBuffer[i] = stream.fDataBuffer[i];
 477     fPackedDataBuffer[i] = stream.fPackedDataBuffer[i];
 478   }
 479
 480   fTOFrawData = stream.fTOFrawData;
 481
 482   fLocalEventCounterDRM = stream.fLocalEventCounterDRM;
 483   fLocalEventCounterLTM = stream.fLocalEventCounterLTM;
 484   for (Int_t j=0;j<13;j++){
 485     fLocalEventCounterTRM[j] = stream.fLocalEventCounterTRM[j];
 486     for (Int_t k=0;k<2;k++){
 487       fLocalEventCounterChain[j][k] = stream.fLocalEventCounterChain[j][k];
 488       fChainBunchID[j][k] = stream.fChainBunchID[j][k];
 489     }
 490   }
 491
 492   //fCableLengthMap = stream.fCableLengthMap;
 493
 494   fEventID = stream.fEventID;
 495   fNewDecoderVersion = stream.fNewDecoderVersion;
 496
 497   return *this;
 498
 499 }
 500
 501 //_____________________________________________________________________________
 502 AliTOFRawStream::~AliTOFRawStream()
 503 {
 504   // destructor
 505
 506   fPackedDigits = 0;
 507
 508   delete fDecoder;
 509   delete fDecoderV2;
 510
 511   if (fTOFrawData) {
 512     fTOFrawData->Clear("C");
 513     delete fTOFrawData;
 514   }
 515
 516   //delete fCableLengthMap;
 517
 518 }
 519
 520
 521 //_____________________________________________________________________________
 522
 523 void AliTOFRawStream::LoadRawData(Int_t indexDDL)
 524 {
 525   //
 526   // To load raw data
 527   //
 528
 529   fEventID = (Int_t)fRawReader->GetBCID(); //bunch crossing
 530
 531   fTOFrawData->Clear();
 532
 533   TClonesArray &arrayTofRawData =  *fTOFrawData;
 534
 535   fPackedDigits = 0;
 536
 537   // create raw data map
 538   AliTOFRawMap rawMap(fTOFrawData);
 539   rawMap.Clear();
 540
 541   Int_t slot[4] = {-1, -1, -1, -1};
 542
 543   fLocalEventCounterDRM = -1;
 544   fLocalEventCounterLTM = -1;
 545   for (Int_t ii=0; ii<13; ii++)
 546     fLocalEventCounterTRM[ii] = -1;
 547   for (Int_t ii=0; ii<13; ii++)
 548     for (Int_t jj=0; jj<2; jj++) {
 549       fLocalEventCounterChain[ii][jj] = -1;
 550       fChainBunchID[ii][jj] = -1;
 551     }
 552
 553   fRawReader->Reset();
 554   fRawReader->Select("TOF", indexDDL, indexDDL);
 555
 556   Bool_t signal = kFALSE;
 557
 558   AliTOFrawData *rawDigit = NULL;
 559
 560   while(Next()) {
 561
 562     signal = (fSector!=-1 && fPlate!=-1 && fStrip!=-1 && fPadZ!=-1 && fPadX!=-1);
 563     if (signal) {
 564       AliDebug(2,Form("  %2i  %1i  %2i  %1i  %2i", fSector, fPlate, fStrip, fPadZ, fPadX));
 565
 566       slot[0] = fTRM;
 567       slot[1] = fTRMchain;
 568       slot[2] = fTDC;
 569       slot[3] = fTDCchannel;
 570
 571       if (rawMap.TestHit(slot) != kEmpty) {
 572
 573         rawDigit = static_cast<AliTOFrawData*>(rawMap.GetHit(slot));
 574
 575         if (rawDigit->GetLeading()!=-1 && rawDigit->GetTrailing()==-1 &&
 576             fLeadingEdge==-1 && fTrailingEdge!=-1) {
 577
 578           rawDigit->Update(fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
 579         }
 580         else if ( ((rawDigit->GetTOF()!=-1 || rawDigit->GetLeading()!=-1 || rawDigit->GetTrailing()!=-1) &&
 581                    (fLeadingEdge!=-1 || fTrailingEdge!=-1 || fTime!=-1) )
 582
 583                   )
 584           {
 585
 586             new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(fTRM, fTRMchain, fTDC, fTDCchannel, fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
 587
 588             rawMap.SetHit(slot);
 589
 590           }
 591
 592
 593       }
 594       else {
 595
 596         new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(fTRM, fTRMchain, fTDC, fTDCchannel, fTime, fToT, fLeadingEdge, fTrailingEdge, fPSbit, fACQ, fErrorFlag);
 597
 598         rawMap.SetHit(slot);
 599
 600       } // else if (rawMap.TestHit(slot) == kEmpty)
 601
 602     } // if (signal)
 603
 604   } // closed -> while (Next())
 605
 606 }
 607
 608 //_____________________________________________________________________________
 609 Bool_t AliTOFRawStream::Next()
 610 {
 611   //
 612   // Read next 32-bit word in TOF raw data files
 613   // returns kFALSE if there is no word left
 614   //
 615
 616   UInt_t data;
 617
 618   Int_t dummy = 0;
 619
 620   if (!fRawReader->ReadNextInt(data)) return kFALSE;
 621
 622   if (fSector!=-1 && fPlate!=-1 && fStrip!=-1 && fPadZ!=-1 && fPadX!=-1) {
 623     fSector = -1;
 624     fPlate  = -1;
 625     fStrip  = -1;
 626     fPadZ   = -1;
 627     fPadX   = -1;
 628     fTime   = -1;
 629     fToT    = -1;
 630     fLeadingEdge  = -1;
 631     fTrailingEdge = -1;
 632   }
 633
 634   fDDL  = fRawReader->GetDDLID();
 635   if (fDDL==-1) {
 636     fRawReader->AddMajorErrorLog(kDDLdataReading);
 637     AliWarning("Error when load DDL. Go to next DDL");
 638     return kFALSE;
 639   }
 640
 641   fWordType = GetField(data,WORD_TYPE_MASK,WORD_TYPE_POSITION);
 642
 643   switch (fWordType) { // switch word type
 644
 645   case GLOBAL_HEADER_TYPE: // global header
 646     fSlotID = GetField(data, HEADER_SLOT_ID_MASK, HEADER_SLOT_ID_POSITION);
 647     fTRM = fSlotID;
 648
 649
 650     switch (fSlotID) { // switch global header slot ID
 651
 652     case DRM_ID_NUMBER: //DRM global header
 653       if (fInsideDRM) { // unexpected DRM global headers -> exit
 654         break;
 655       }
 656       fInsideDRM = kTRUE; // DRM global header accepted
 657       break;
 658
 659     case LTM_ID_NUMBER: // LTM global header
 660       if (fInsideLTM) { // unexpected LTM global headers -> exit
 661         break;
 662       }
 663       fInsideLTM = kTRUE; // LTM global header accepted
 664       break;
 665
 666     case  3: //TRM header
 667     case  4: //TRM header
 668     case  5: //TRM header
 669     case  6: //TRM header
 670     case  7: //TRM header
 671     case  8: //TRM header
 672     case  9: //TRM header
 673     case 10: //TRM header
 674     case 11: //TRM header
 675     case 12: //TRM header
 676       if (fInsideTRM) { // unexpected TRM global headers -> exit
 677         break;
 678       }
 679       fInsideTRM = kTRUE; // TRM global header accepted
 680       fACQ =  GetField(data,TRM_ACQ_BITS_MASK,TRM_ACQ_BITS_POSITION);
 681       break;
 682
 683     default: // unexpected global header slot ID
 684       break;
 685
 686     } //end switch global header slot id
 687
 688     break;
 689
 690
 691   case GLOBAL_TRAILER_TYPE: // global trailer
 692     fSlotID = GetField(data,HEADER_SLOT_ID_MASK,HEADER_SLOT_ID_POSITION);
 693
 694     switch (fSlotID) { // switch global trailer slot ID
 695
 696     case DRM_ID_NUMBER: // DRM global trailer
 697       if (!fInsideDRM) { // unexpected DRM global trailers -> exit
 698         break;
 699       }
 700       dummy = 0x0000fff0;
 701       //AliInfo(Form("  DRM local event counter = %i", GetField(data,dummy,4)));
 702       fLocalEventCounterDRM = GetField(data,dummy,4);
 703       fInsideDRM = kFALSE; // DRM global trailer accepted
 704       fInsideTRM = kFALSE;
 705       fInsideLTM = kFALSE;
 706       fInsideTRMchain0 = kFALSE;
 707       fInsideTRMchain1 = kFALSE;
 708       fSector = -1;
 709       fPlate  = -1;
 710       fStrip  = -1;
 711       fPadZ   = -1;
 712       fPadX   = -1;
 713       fDDL        = -1;
 714       fTRM        = -1;
 715       fTDC        = -1;
 716       fTRMchain   = -1;
 717       fTDCchannel = -1;
 718       fTime = -1;
 719       fToT  = -1;
 720       fLeadingEdge  = -1;
 721       fTrailingEdge = -1;
 722       fErrorFlag = -1;
 723       fACQ   = -1;
 724       fPSbit = -1;
 725       fTDCerrorFlag = -1;
 726       break;
 727     case LTM_ID_NUMBER: // LTM global trailer
 728       if (!fInsideLTM) { // unexpected LTM global trailer -> exit
 729         break;
 730       }
 731       dummy = 0x0fff0000;
 732       //AliInfo(Form("  LTM local event counter = %i", GetField(data,dummy,16)));
 733       fLocalEventCounterLTM = GetField(data,dummy,16);
 734       fInsideLTM = kFALSE; // LTM global trailer accepted
 735       break;
 736     case 15: //TRM global trailer
 737       if (!fInsideTRM) { // unexpected TRM global trailers -> exit
 738         break;
 739       }
 740       dummy = 0x0fff0000;
 741       //AliInfo(Form("  TRM local event counter = %i", GetField(data,dummy,16)));
 742       fLocalEventCounterTRM[fTRM] = GetField(data,dummy,16);
 743       fInsideTRM = kFALSE; // TRM global trailer accepted
 744       break;
 745     default: // unexpected global trailer slot ID
 746       break;
 747     } //end switch global trailer slot id
 748
 749
 750     break;
 751
 752
 753   case ERROR_TYPE: // TDC error
 754     fTDC          = GetField(data,TRM_TDC_ERROR_TDC_ID_MASK,TRM_TDC_ERROR_TDC_ID_POSITION);
 755     fTDCerrorFlag = GetField(data,TRM_TDC_ERROR_FLAGS_MASK,TRM_TDC_ERROR_FLAGS_POSITION);
 756     break;
 757
 758
 759   case FILLER_TYPE: // filler
 760     break;
 761
 762
 763   default: // other word types
 764
 765     if (fInsideTRM) { // inside TRM
 766
 767       switch (fWordType) { // switch word type inside TRM
 768       case TRM_CHAIN0_HEADER_TYPE: // TRM chain0 header
 769         if (fInsideTRMchain0) { // unexpected TRM chain0 header
 770           break;
 771         }
 772         fInsideTRMchain0 = kTRUE;
 773         fTRMchain = 0;
 774         dummy = 0x0000fff0;
 775         //AliInfo(Form("  chain bunch ID = %i", GetField(data,dummy,4)));
 776         fChainBunchID[fTRM][fTRMchain] = GetField(data,dummy,4);
 777         break;
 778       case TRM_CHAIN0_TRAILER_TYPE: // TRM chain0 trailer
 779         if (!fInsideTRMchain0) { // unexpected TRM chain0 trailer
 780           break;
 781         }
 782         dummy = 0x0fff0000;
 783         //AliInfo(Form("  chain local event counter = %i", GetField(data,dummy,16)));
 784         fLocalEventCounterChain[fTRM][fTRMchain] = GetField(data,dummy,16);
 785         fInsideTRMchain0 = kFALSE;
 786         fTRMchain = -1;
 787         break;
 788       case TRM_CHAIN1_HEADER_TYPE: // TRM chain1 header
 789         if (fInsideTRMchain1) { // unexpected TRM chain1 header
 790           break;
 791         }
 792         fInsideTRMchain1 = kTRUE;
 793         fTRMchain = 1;
 794         dummy = 0x0000fff0;
 795         //AliInfo(Form("  chain bunch ID = %i", GetField(data,dummy,4)));
 796         fChainBunchID[fTRM][fTRMchain] = GetField(data,dummy,4);
 797         break;
 798       case TRM_CHAIN1_TRAILER_TYPE: // TRM chain1 trailer
 799         if (!fInsideTRMchain1) { // unexpected TRM chain1 trailer
 800           break;
 801         }
 802         dummy = 0x0fff0000;
 803         //AliInfo(Form("  chain local event counter = %i", GetField(data,dummy,16)));
 804         fLocalEventCounterChain[fTRM][fTRMchain] = GetField(data,dummy,16);
 805         fInsideTRMchain1 = kFALSE;
 806         fTRMchain = -1;
 807         break;
 808       } // end switch word type inside TRM
 809
 810     } // end if (fInsideTRM)
 811
 812
 813     if (
 814         ((fInsideTRMchain0&&!fInsideTRMchain1) || (!fInsideTRMchain0&&fInsideTRMchain1))
 815         && fWordType!=TRM_CHAIN0_HEADER_TYPE && fWordType!=TRM_CHAIN0_TRAILER_TYPE
 816         && fWordType!=TRM_CHAIN1_HEADER_TYPE && fWordType!=TRM_CHAIN1_TRAILER_TYPE
 817         ){ // inside TRM chains
 818
 819       fPSbit      = GetField(data,TRM_PS_BITS_MASK,TRM_PS_BITS_POSITION);
 820       fTDC        = GetField(data,TRM_TDC_ID_MASK,TRM_TDC_ID_POSITION);
 821       fTDCchannel = GetField(data,TRM_CHAN_MASK,TRM_CHAN_POSITION);
 822       fErrorFlag  = GetField(data,TRM_E_BIT_MASK,TRM_E_BIT_POSITION);
 823
 824       SetSector();
 825       SetPlate();
 826       SetStrip();
 827       SetPadZ();
 828       SetPadX();
 829
 830
 831       switch (fPSbit) { // switch fPSbit bits inside TRM chains
 832
 833       case 0: // packing ok, digit time and TOT
 834         fToT  = GetField(data,TRM_TOT_WIDTH_MASK, TRM_TOT_WIDTH_POSITION);
 835         fTime = GetField(data,TRM_DIGIT_TIME_MASK,TRM_DIGIT_TIME_POSITION)
 836           /*-
 837           fCableLengthMap->GetCableTimeShiftBin(fDDL, fTRM, fTRMchain, fTDC)*/
 838           ;
 839         if (fgApplyBCCorrections) {
 840           AliDebug(2,"Apply nominal DDL BC time-shift correction");
 841           AliDebug(2,"Apply deltaBC time-shift correction");
 842           AliDebug(2,Form(" fChainBunchID[%d][%d] = %d ,fEventID = %d",fTRM,fTRMchain,fChainBunchID[fTRM][fTRMchain],fEventID));
 843           fTime += fgkddlBCshift[fDDL] * 1024 + (fChainBunchID[fTRM][fTRMchain] - fEventID) * 1024;
 844         }
 845         break;
 846
 847       case 1: // leading edge digit, long digit time, no TOT
 848         //fToT  = -1;
 849         //fTime  = -1;
 850         fLeadingEdge = GetField(data,TRM_LONG_DIGIT_TIME_MASK,TRM_LONG_DIGIT_TIME_POSITION)
 851           /*-
 852           fCableLengthMap->GetCableTimeShiftBin(fDDL, fTRM, fTRMchain, fTDC)*/
 853           ;
 854         if (fgApplyBCCorrections) {
 855           AliDebug(2,"Apply nominal DDL BC time-shift correction");
 856           AliDebug(2,"Apply deltaBC time-shift correction");
 857           AliDebug(2,Form(" fChainBunchID[%d][%d] = %d ,fEventID = %d",fTRM,fTRMchain,fChainBunchID[fTRM][fTRMchain],fEventID));
 858           fLeadingEdge += fgkddlBCshift[fDDL] * 1024 + (fChainBunchID[fTRM][fTRMchain] - fEventID) * 1024;
 859         }
 860         break;
 861
 862       case 2: // trailing edge digit, long digit time, no TOT
 863         //fToT  = -1;
 864         //fTime  = -1;
 865         fTrailingEdge = GetField(data,TRM_LONG_DIGIT_TIME_MASK,TRM_LONG_DIGIT_TIME_POSITION)
 866           /*-
 867           fCableLengthMap->GetCableTimeShiftBin(fDDL, fTRM, fTRMchain, fTDC)*/
 868           ;
 869         if (fgApplyBCCorrections) {
 870           AliDebug(2,"Apply nominal DDL BC time-shift correction");
 871           AliDebug(2,"Apply deltaBC time-shift correction");
 872           AliDebug(2,Form(" fChainBunchID[%d][%d] = %d ,fEventID = %d",fTRM,fTRMchain,fChainBunchID[fTRM][fTRMchain],fEventID));
 873           fTrailingEdge += fgkddlBCshift[fDDL] * 1024 + (fChainBunchID[fTRM][fTRMchain] - fEventID) * 1024;
 874         }
 875         break;
 876
 877       case 3: // TOT overflow
 878         fToT  = GetField(data,TRM_TOT_WIDTH_MASK, TRM_TOT_WIDTH_POSITION);
 879         fTime = GetField(data,TRM_DIGIT_TIME_MASK,TRM_DIGIT_TIME_POSITION)
 880           /*-
 881           fCableLengthMap->GetCableTimeShiftBin(fDDL, fTRM, fTRMchain, fTDC)*/
 882           ;
 883         if (fgApplyBCCorrections) {
 884           AliDebug(2,"Apply nominal DDL BC time-shift correction");
 885           AliDebug(2,"Apply deltaBC time-shift correction");
 886           AliDebug(2,Form(" fChainBunchID[%d][%d] = %d ,fEventID = %d",fTRM,fTRMchain,fChainBunchID[fTRM][fTRMchain],fEventID));
 887           fTime += fgkddlBCshift[fDDL] * 1024 + (fChainBunchID[fTRM][fTRMchain] - fEventID) * 1024;
 888         }
 889         break;
 890
 891       } // end switch PS bits inside TRM chains
 892
 893     } // end if is inside TRM chains
 894
 895   } // end switch on fWordType
 896
 897
 898   return kTRUE;
 899
 900 }
 901 //_____________________________________________________________________________
 902
 903 void AliTOFRawStream::SetSector()
 904 {
 905   //
 906   // Evaluate the TOF sector number -> [ 0;17]
 907   // corresponding to the TOF equipment IDs:
 908   //                                  fDDL        -> [ 0;71]
 909   //                                  fTRM        -> [ 3;12]
 910   //                                  fTRMchain   -> [ 0; 1]
 911   //                                  fTDC        -> [ 0;14]
 912   //                                  fTDCchannel -> [ 0; 7]
 913   //
 914
 915   Int_t iSector = -1;
 916
 917   if (!(fDDL==-1)) iSector = Int_t((Float_t)(fDDL)/AliTOFGeometry::NDDL());
 918
 919   fSector = iSector;
 920
 921 }
 922 //_____________________________________________________________________________
 923
 924
 925 void AliTOFRawStream::SetPlate()
 926 {
 927   //
 928   // Evaluate the TOF plate number ->[ 0; 4]
 929   // corresponding to the TOF equipment IDs:
 930   //                                  fDDL        -> [ 0;71]
 931   //                                  fTRM        -> [ 3;12]
 932   //                                  fTRMchain   -> [ 0; 1]
 933   //                                  fTDC        -> [ 0;14]
 934   //                                  fTDCchannel -> [ 0; 7]
 935   //
 936
 937   Int_t iPlate = -1;
 938   if (!(fDDL==-1 || fTRM==-1 || fTDC==-1
 939         || fSector==-1))
 940     iPlate = Equip2VolNplate(GetDDLnumberPerSector(fDDL), fTRM, fTDC);
 941
 942   fPlate = iPlate;
 943
 944 }
 945 //_____________________________________________________________________________
 946
 947 void AliTOFRawStream::SetStrip()
 948 {
 949   //
 950   // Evaluate the TOF strip number per module -> [ 0; 14/18]
 951   // corresponding to the TOF equipment IDs:
 952   //                                  fDDL        -> [ 0;71]
 953   //                                  fTRM        -> [ 3;12]
 954   //                                  fTRMchain   -> [ 0; 1]
 955   //                                  fTDC        -> [ 0;14]
 956   //                                  fTDCchannel -> [ 0; 7]
 957   //
 958
 959   Int_t iStrip = -1;
 960
 961   if (!(fDDL==-1 || fTRM==-1 || fTDC==-1
 962         || fSector==-1 || fPlate==-1))
 963     iStrip = Equip2VolNstrip(GetDDLnumberPerSector(fDDL), fTRM, fTDC);
 964
 965   fStrip = iStrip;
 966
 967 }
 968 //_____________________________________________________________________________
 969
 970 void AliTOFRawStream::SetPadZ()
 971 {
 972   //
 973   // Evaluate the TOF padRow number per strip -> [ 0; 1]
 974   // corresponding to the TOF equipment IDs:
 975   //                                  fDDL        -> [ 0;71]
 976   //                                  fTRM        -> [ 3;12]
 977   //                                  fTRMchain   -> [ 0; 1]
 978   //                                  fTDC        -> [ 0;14]
 979   //                                  fTDCchannel -> [ 0; 7]
 980   //
 981
 982   Int_t iPadZ = -1;
 983
 984   if (!(fDDL==-1 || fTRM==-1 || fTRMchain==-1 || fTDC==-1 || fTDCchannel==-1
 985         || fSector==-1 || fPlate==-1 || fStrip==-1))
 986     {
 987       Int_t iPadAlongTheStrip = Equip2VolNpad(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel);
 988       if (iPadAlongTheStrip!=-1)
 989         iPadZ  = iPadAlongTheStrip%AliTOFGeometry::NpadZ();
 990     }
 991
 992   //iPadZ = Equip2VolNpad(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel)%AliTOFGeometry::NpadZ();
 993   //iPadZ = Equip2VolNpadZ(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel);
 994
 995   fPadZ = iPadZ;
 996
 997 }
 998 //_____________________________________________________________________________
 999
1000 void AliTOFRawStream::SetPadX()
1001 {
1002   //
1003   // Evaluate the TOF pad number per strip padRow -> [ 0;47]
1004   // corresponding to the TOF equipment IDs:
1005   //                                  fDDL        -> [ 0;71]
1006   //                                  fTRM        -> [ 3;12]
1007   //                                  fTRMchain   -> [ 0; 1]
1008   //                                  fTDC        -> [ 0;14]
1009   //                                  fTDCchannel -> [ 0; 7]
1010   //
1011
1012   Int_t iPadX = -1;
1013
1014   if (!(fDDL==-1 || fTRM==-1 || fTRMchain==-1 || fTDC==-1 || fTDCchannel==-1
1015         || fSector==-1 || fPlate==-1 || fStrip==-1))
1016     {
1017       Int_t iPadAlongTheStrip = Equip2VolNpad(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel);
1018       if (iPadAlongTheStrip!=-1)
1019         iPadX  = (Int_t)(iPadAlongTheStrip/(Float_t(AliTOFGeometry::NpadZ())));
1020     }
1021
1022   //iPadX = (Int_t)(Equip2VolNpad(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel)/(Float_t(AliTOFGeometry::NpadZ())));
1023   //iPadX = Equip2VolNpadX(GetDDLnumberPerSector(fDDL), fTRMchain, fTDC, fTDCchannel);
1024
1025   fPadX = iPadX;
1026
1027 }
1028
1029 //----------------------------------------------------------------------------
1030 Int_t AliTOFRawStream::GetField(UInt_t word, Int_t fieldMask, Int_t fieldPosition) const
1031 {
1032   //
1033   // Returns 'word' masked by 'fieldMask' and shifted by 'fieldPosition'
1034   //
1035
1036   return ((word & fieldMask) >> fieldPosition);
1037 }
1038
1039 //----------------------------------------------------------------------------
1040 Int_t AliTOFRawStream::Equip2VolNplate(Int_t iDDL, Int_t nTRM, Int_t nTDC)
1041 {
1042   //
1043   // Returns the TOF plate number [0;4]
1044   // corresponding to the TOF equipment ID numbers:
1045   //                          iDDL -> DDL number per sector [0;3]
1046   //                          nTRM -> TRM number [3;12]
1047   //                          nTDC -> TDC number [0;14]
1048   //
1049
1050   Int_t iPlate = -1;
1051
1052   if (iDDL==0) {
1053
1054     if (nTRM>=4 && nTRM<7) {
1055       iPlate = 0;
1056     } else if (nTRM==7) {
1057       if (nTDC<12) iPlate = 0;
1058       else iPlate = 1;
1059     } else if (nTRM>=8 && nTRM<11) {
1060       iPlate = 1;
1061     } else if (nTRM==11) {
1062       if (nTDC<9) iPlate = 1;
1063       else iPlate = 2;
1064     }else if (nTRM==12) {
1065       iPlate = 2;
1066     }
1067
1068   } else if (iDDL==1) {
1069
1070     if (nTRM==3) {
1071       if (nTDC<3) iPlate = 0;
1072     } else if (nTRM>=4 && nTRM<7) {
1073       iPlate = 0;
1074     } else if (nTRM==7) {
1075       if (nTDC<6) iPlate = 1;
1076       else iPlate = 0;
1077     } else if (nTRM>=8 && nTRM<11) {
1078       iPlate = 1;
1079     } else if (nTRM==11) {
1080       if (nTDC<9) iPlate = 2;
1081       else iPlate = 1;
1082     } else if (nTRM==12) {
1083       iPlate = 2;
1084     }
1085
1086   } else if (iDDL==2) {
1087
1088     if (nTRM>=4 && nTRM<7) {
1089       iPlate = 4;
1090     } else if (nTRM==7) {
1091       if (nTDC<12) iPlate = 4;
1092       else iPlate = 3;
1093     } else if (nTRM>=8 && nTRM<11) {
1094       iPlate = 3;
1095     } else if (nTRM==11) {
1096       if (nTDC<9) iPlate = 3;
1097       else iPlate = 2;
1098     }else if (nTRM==12) {
1099       iPlate = 2;
1100     }
1101
1102   }  else if (iDDL==3) {
1103
1104     if (nTRM==3) {
1105       if (nTDC<3) iPlate = 4;
1106     } else if (nTRM>=4 && nTRM<7) {
1107       iPlate = 4;
1108     } else if (nTRM==7) {
1109       if (nTDC<6) iPlate = 3;
1110       else iPlate = 4;
1111     } else if (nTRM>=8 && nTRM<11) {
1112       iPlate = 3;
1113     } else if (nTRM==11) {
1114       if (nTDC<9) iPlate = 2;
1115       else iPlate = 3;
1116     } else if (nTRM==12) {
1117       iPlate = 2;
1118     }
1119
1120   }
1121
1122   return iPlate;
1123
1124 }
1125
1126 //----------------------------------------------------------------------------
1127 Int_t AliTOFRawStream::Equip2VolNstrip(Int_t iDDL, Int_t nTRM, Int_t nTDC)
1128 {
1129   //
1130   // Returns the TOF strip number per module:
1131   //                                [0;14], in the central plates,
1132   //                                [0;18], in the intermediate and external plates
1133   // corresponding to the TOF equipment ID numbers:
1134   //                                iDDL -> DDL number per sector [0;3]
1135   //                                nTRM -> TRM number [3;12]
1136   //                                nTDC -> TDC number [0;14]
1137   //
1138
1139   Int_t iStrip = -1;
1140
1141   if (iDDL==0) {
1142
1143     if (nTRM== 4) iStrip =  (Int_t)(nTDC/3.);
1144     else if (nTRM== 5) iStrip =  5 + (Int_t)(nTDC/3.);
1145     else if (nTRM== 6) iStrip = 10 + (Int_t)(nTDC/3.);
1146     else if (nTRM== 7) {
1147       if (nTDC<12) iStrip =  15 + (Int_t)(nTDC/3.);
1148       else iStrip = (Int_t)(nTDC/3.) -  4;
1149     }
1150     else if (nTRM== 8) iStrip =  1 + (Int_t)(nTDC/3.);
1151     else if (nTRM== 9) iStrip =  6 + (Int_t)(nTDC/3.);
1152     else if (nTRM==10) iStrip = 11 + (Int_t)(nTDC/3.);
1153     else if (nTRM==11) {
1154       if (nTDC<9) iStrip = 16 + (Int_t)(nTDC/3.);
1155       else iStrip = (Int_t)(nTDC/3.) -  3;
1156     }
1157     else if (nTRM==12) iStrip =  2 + (Int_t)(nTDC/3.);
1158
1159   } else if (iDDL==1) {
1160
1161     if (nTRM==3 && nTDC<3) iStrip = (Int_t)(nTDC/3.);
1162     else if (nTRM== 4) iStrip =  5 - (Int_t)(nTDC/3.);
1163     else if (nTRM== 5) iStrip = 10 - (Int_t)(nTDC/3.);
1164     else if (nTRM== 6) iStrip = 15 - (Int_t)(nTDC/3.);
1165     else if (nTRM== 7) {
1166       if (nTDC<6) iStrip =  1 - (Int_t)(nTDC/3.);
1167       else iStrip = 20 - (Int_t)(nTDC/3.);
1168     }
1169     else if (nTRM== 8) iStrip =  6 - (Int_t)(nTDC/3.);
1170     else if (nTRM== 9) iStrip = 11 - (Int_t)(nTDC/3.);
1171     else if (nTRM==10) iStrip = 16 - (Int_t)(nTDC/3.);
1172     else if (nTRM==11) {
1173       if (nTDC<9) iStrip =  2 - (Int_t)(nTDC/3.);
1174       else iStrip = 21 - (Int_t)(nTDC/3.);
1175     }
1176     else if (nTRM==12) iStrip =  7 - (Int_t)(nTDC/3.);
1177
1178   } else if (iDDL==2) {
1179
1180     if (nTRM== 4) iStrip =  18 - (Int_t)(nTDC/3.);
1181     else if (nTRM== 5) iStrip = 18 - ( 5 + (Int_t)(nTDC/3.));
1182     else if (nTRM== 6) iStrip = 18 - (10 + (Int_t)(nTDC/3.));
1183     else if (nTRM== 7) {
1184       if (nTDC<12) iStrip =  18 - (15 + (Int_t)(nTDC/3.));
1185       else iStrip = 18 - ((Int_t)(nTDC/3.) -  4);
1186     }
1187     else if (nTRM== 8) iStrip = 18 - ( 1 + (Int_t)(nTDC/3.));
1188     else if (nTRM== 9) iStrip = 18 - ( 6 + (Int_t)(nTDC/3.));
1189     else if (nTRM==10) iStrip = 18 - (11 + (Int_t)(nTDC/3.));
1190     else if (nTRM==11) {
1191       if (nTDC<9) iStrip = 18 - (16 + (Int_t)(nTDC/3.));
1192       else iStrip = 14 - ((Int_t)(nTDC/3.) -  3);
1193     }
1194     else if (nTRM==12) iStrip = 14 - ( 2 + (Int_t)(nTDC/3.));
1195
1196   } else if (iDDL==3) {
1197
1198     if (nTRM==3 && nTDC<3) iStrip = 18 - (Int_t)(nTDC/3.);
1199     else if (nTRM== 4) iStrip = 18 - ( 5 - (Int_t)(nTDC/3.));
1200     else if (nTRM== 5) iStrip = 18 - (10 - (Int_t)(nTDC/3.));
1201     else if (nTRM== 6) iStrip = 18 - (15 - (Int_t)(nTDC/3.));
1202     else if (nTRM== 7) {
1203       if (nTDC<6) iStrip =  18 - (1 - (Int_t)(nTDC/3.));
1204       else iStrip = 18 - (20 - (Int_t)(nTDC/3.));
1205     }
1206     else if (nTRM== 8) iStrip = 18 - ( 6 - (Int_t)(nTDC/3.));
1207     else if (nTRM== 9) iStrip = 18 - (11 - (Int_t)(nTDC/3.));
1208     else if (nTRM==10) iStrip = 18 - (16 - (Int_t)(nTDC/3.));
1209     else if (nTRM==11) {
1210       if (nTDC<9) iStrip = 14 - ( 2 - (Int_t)(nTDC/3.));
1211       else iStrip = 18 - (21 - (Int_t)(nTDC/3.));
1212     }
1213     else if (nTRM==12) iStrip = 14 - ( 7 - (Int_t)(nTDC/3.));
1214
1215   }
1216
1217   return iStrip;
1218
1219 }
1220
1221 //----------------------------------------------------------------------------
1222 Int_t AliTOFRawStream::Equip2VolNpad(Int_t iDDL, Int_t iChain, Int_t nTDC,
1223                                      Int_t iCH)
1224 {
1225   //
1226   // Returns the TOF pad number per strip [0;95]
1227   // corresponding to the TOF equipment ID numbers:
1228   //                          iDDL -> DDL number per sector [0;3]
1229   //                        iChain -> TRM chain number [0;1]
1230   //                          nTDC -> TDC number [0;14]
1231   //                           iCH -> TDC channel number [0;7]
1232   //
1233
1234   Int_t iPadAlongTheStrip = -1;
1235
1236   // wrong
1237   //Int_t iTDClocal = nTDC%3 + (1-iChain)*3;
1238   //if (iDDL==0 || iDDL==3) iTDClocal = 5 - iTDClocal;
1239   //else if (iDDL==1 || iDDL==2) iTDClocal = 6 + (5 - iTDClocal);
1240
1241   // right
1242   Int_t iTDClocal = -1;
1243   Int_t iTDClocal03 = nTDC%3 + (1-iChain)*3;
1244   Int_t iTDClocal12 = 2-nTDC%3 + iChain*3;
1245   if (iDDL==0 || iDDL==3) iTDClocal = 5 - iTDClocal03;
1246   else if (iDDL==1 || iDDL==2) iTDClocal = 6 + (5 - iTDClocal12);
1247
1248   Int_t iCHlocal = iCH;
1249   if (iDDL==0 || iDDL==3) iCHlocal = 7 - iCH;
1250
1251   iPadAlongTheStrip = iTDClocal*AliTOFGeometry::NCh() + iCHlocal;
1252
1253   if (((iDDL==1 || iDDL==2) && iPadAlongTheStrip< AliTOFGeometry::NpadX()) ||
1254       ((iDDL==0 || iDDL==3) && iPadAlongTheStrip>=AliTOFGeometry::NpadX())) {
1255     std::cerr << "Warning -> AliTOFRawStream::Equip2VolNpad: Problems with the padX number!\n";
1256     //AliWarning("Problems with the padX number!");
1257   }
1258   return iPadAlongTheStrip;
1259
1260 }
1261
1262 //----------------------------------------------------------------------------
1263 Int_t AliTOFRawStream::Equip2VolNpadX(Int_t iDDL, Int_t iChain, Int_t nTDC,
1264                                       Int_t iCH)
1265 {
1266   //
1267   // Returns the TOF padX number [0;47]
1268   // corresponding to the TOF equipment ID numbers:
1269   //                          iDDL -> DDL number per sector [0;3]
1270   //                        iChain -> TRM chain number [0;1]
1271   //                          nTDC -> TDC number [0;14]
1272   //                           iCH -> TDC channel number [0;7]
1273   //
1274
1275   Int_t iPadX = (Int_t)(AliTOFRawStream::Equip2VolNpad(iDDL, iChain, nTDC, iCH)/
1276                         (Float_t(AliTOFGeometry::NpadZ())));
1277
1278   return iPadX;
1279
1280 }
1281
1282 //----------------------------------------------------------------------------
1283 Int_t AliTOFRawStream::Equip2VolNpadZ(Int_t iDDL, Int_t iChain, Int_t nTDC,
1284                                       Int_t iCH)
1285 {
1286   //
1287   // Returns the TOF padZ number [0;1]
1288   // corresponding to the TOF equipment ID numbers:
1289   //                          iDDL -> DDL number per sector [0;3]
1290   //                        iChain -> TRM chain number [0;1]
1291   //                          nTDC -> TDC number [0;14]
1292   //                           iCH -> TDC channel number [0;7]
1293   //
1294
1295   Int_t iPadZ  = AliTOFRawStream::Equip2VolNpad(iDDL, iChain, nTDC, iCH)%AliTOFGeometry::NpadZ();
1296
1297   return iPadZ;
1298
1299 }
1300
1301 //----------------------------------------------------------------------------
1302 Int_t AliTOFRawStream::GetSectorNumber(Int_t nDDL)
1303 {
1304   //
1305   // Returns the sector number [0;17]
1306   // corresponing to the assigned DRM/DDL number [0;71]
1307   //
1308
1309   Int_t iSector = Int_t((Float_t)(nDDL)/AliTOFGeometry::NDDL());
1310
1311   return iSector;
1312
1313 }
1314 //----------------------------------------------------------------------------
1315 Int_t AliTOFRawStream::GetDDLnumberPerSector(Int_t nDDL)
1316 {
1317   //
1318   // Return the DRM/DDL number per sector [0;3]
1319   // corresponing to the assigned DRM/DDL number [0;71]
1320   //
1321
1322   Int_t iDDL = nDDL%AliTOFGeometry::NDDL();
1323
1324   return iDDL;
1325
1326 }
1327
1328 //----------------------------------------------------------------------------
1329 void AliTOFRawStream::EquipmentId2VolumeId(AliTOFHitData *hitData, Int_t *volume) const
1330 {
1331   EquipmentId2VolumeId(hitData->GetDDLID(),hitData->GetSlotID(),hitData->GetChain(),hitData->GetTDC(),hitData->GetChan(),volume);
1332 }
1333 //----------------------------------------------------------------------------
1334 void AliTOFRawStream::EquipmentId2VolumeId(Int_t nDDL, Int_t nTRM, Int_t iChain,
1335                                            Int_t nTDC, Int_t iCH,
1336                                            Int_t *volume)
1337 {
1338   //
1339   // To convert:
1340   //            nDDL   (variable in [0;71]) -> number of the DDL file
1341   //            nTRM   (variable in [3;12]) -> number of the TRM slot
1342   //            iChain (variable in [0; 1]) -> number of the TRM chain
1343   //            nTDC   (variable in [0;14]) -> number of the TDC
1344   //            iCH    (variable in [0; 7]) -> number of the TDC channel
1345   //
1346   // in:
1347   //      sector number, i.e. volume[0] (variable in [0,17])
1348   //      plate  number, i.e. volume[1] (variable in [0, 5])
1349   //      strip  number, i.e. volume[2] (variable in [0,14/18])
1350   //      padX   number, i.e. volume[3] (variable in [0,47])
1351   //      padZ   number, i.e. volume[4] (variable in [0, 1])
1352   //
1353
1354   for (Int_t ii=0; ii<5; ii++) volume[ii] = -1;
1355
1356   Int_t iDDL = GetDDLnumberPerSector(nDDL);
1357
1358   if (iDDL%2==1 && nTRM==3 && nTDC/3>0) { // Signal not coming from a TOF pad but -probably- from a TOF OR signal
1359     //printf("Info -> AliTOFRawStream::EquipmentId2VolumeId: Signal not coming from a TOF pad but -probably- from a TOF OR signal (%2d %2d %2d)\n", nDDL, nTRM, nTDC);
1360     return;
1361   }
1362
1363   Int_t iSector = GetSectorNumber(nDDL);
1364
1365   Int_t iPlate = Equip2VolNplate(iDDL, nTRM, nTDC);
1366   if (iPlate==-1) {
1367     /*if (fRawReader)
1368       fRawReader->AddMajorErrorLog(kPlateError,"plate = -1");*/
1369     AliWarningGeneral("AliTOFRawStream", Form("Warning -> AliTOFRawStream::EquipmentId2VolumeId: Problems with the plate number (%2d %2d %2d)!\n",
1370                          nDDL, nTRM, nTDC));
1371   }
1372
1373   Int_t iStrip = Equip2VolNstrip(iDDL, nTRM, nTDC);
1374   if (iStrip==-1) {
1375     /*if (fRawReader)
1376       fRawReader->AddMajorErrorLog(kStripError,"strip = -1");*/
1377     AliWarningGeneral("AliTOFRawStream", Form("Warning -> AliTOFRawStream::EquipmentId2VolumeId: Problems with the strip number (%2d %2d %2d)!\n",
1378                          nDDL, nTRM, nTDC));
1379   }
1380
1381   Int_t iPadAlongTheStrip  = Equip2VolNpad(iDDL, iChain, nTDC, iCH);
1382   if (iPadAlongTheStrip==-1) {
1383     /*if (fRawReader)
1384       fRawReader->AddMajorErrorLog(kPadAlongStripError,"pad = -1");*/
1385     AliWarningGeneral("AliTOFRawStream", Form("Warning -> AliTOFRawStream::EquipmentId2VolumeId: Problems with the pad number along the strip (%2d %1d %2d %1d)!\n",
1386                          nDDL, iChain, nTDC, iCH));
1387   }
1388
1389   Int_t iPadX  = (Int_t)(iPadAlongTheStrip/(Float_t(AliTOFGeometry::NpadZ())));
1390   Int_t iPadZ  = iPadAlongTheStrip%AliTOFGeometry::NpadZ();
1391
1392   //Int_t iPadX  = (Int_t)(Equip2VolNpad(iDDL, iChain, nTDC, iCH)/(Float_t(AliTOFGeometry::NpadZ())));
1393   //Int_t iPadZ  = Equip2VolNpad(iDDL, iChain, nTDC, iCH)%AliTOFGeometry::NpadZ();
1394
1395   //Int_t iPadX  = Equip2VolNpadX(iDDL, iChain, nTDC, iCH);
1396   //Int_t iPadZ  = Equip2VolNpadZ(iDDL, iChain, nTDC, iCH);
1397
1398   volume[0] = iSector;
1399   volume[1] = iPlate;
1400   volume[2] = iStrip;
1401   volume[3] = iPadX;
1402   volume[4] = iPadZ;
1403
1404 }
1405 //-----------------------------------------------------------------------------
1406 Bool_t AliTOFRawStream::DecodeDDL(Int_t nDDLMin, Int_t nDDLMax, Int_t verbose = 0) {
1407   //
1408   // To decode raw data for DDL number in [nDDLmin; nDDLmax]
1409   //
1410
1411   //check and fix valid DDL range
1412   if (nDDLMin < 0){
1413     nDDLMin = 0;
1414     fRawReader->AddMinorErrorLog(kDDLMinError);
1415     AliWarning("Wrong DDL range: setting first DDL ID to 0");
1416   }
1417   if (nDDLMax > 71){
1418     nDDLMax = 71;
1419     fRawReader->AddMinorErrorLog(kDDLMaxError);
1420     AliWarning("Wrong DDL range: setting last DDL ID to 71");
1421   }
1422
1423   //select required DDLs
1424   fRawReader->Reset();
1425   fRawReader->Select("TOF", nDDLMin, nDDLMax);
1426
1427   if (verbose)
1428     AliInfo(Form("Selected TOF DDL range: %d-%d", nDDLMin, nDDLMax));
1429
1430   return(Decode(verbose));
1431 }
1432 //-----------------------------------------------------------------------------
1433 Bool_t AliTOFRawStream::Decode(Int_t verbose = 0) {
1434   //
1435   // New decoder method
1436   //
1437
1438   Int_t currentEquipment;
1439   Int_t currentDDL;
1440   const AliRawDataHeader *currentCDH;
1441
1442   //pointers
1443   UChar_t *data = 0x0;
1444
1445   //loop and read DDL headers
1446   while(fRawReader->ReadHeader()){
1447
1448     //memory leak prevention (actually data should be always 0x0 here)
1449     if (data != 0x0)
1450       delete [] data;
1451
1452     //get equipment infos
1453     currentEquipment = fRawReader->GetEquipmentId();
1454
1455     currentDDL = fRawReader->GetDDLID();
1456     if (currentDDL==-1) {
1457       fRawReader->AddMajorErrorLog(kDDLdataReading);
1458       if (verbose)
1459         AliWarning("Error when load DDL. Go to next DDL");
1460       continue;
1461     }
1462
1463     currentCDH = fRawReader->GetDataHeader();
1464     const Int_t kDataSize = fRawReader->GetDataSize();
1465     const Int_t kDataWords = kDataSize / 4;
1466     data = new UChar_t[kDataSize];
1467
1468     if (verbose)
1469       AliInfo(Form("Found equipment # %d header (DDL # %d): %d bytes (%d words)", currentEquipment, currentDDL, kDataSize, kDataWords));
1470
1471     if (verbose)
1472       AliInfo(Form("Reading equipment #%d (DDL # %d) data...", currentEquipment, currentDDL));
1473
1474     //read equipment payload
1475     if (!fRawReader->ReadNext(data, kDataSize))
1476       {
1477         fRawReader->AddMajorErrorLog(kDDLdataReading);
1478         if (verbose)
1479           AliWarning("Error while reading DDL data. Go to next equipment");
1480         delete [] data;
1481         data = 0x0;
1482         continue;
1483       }
1484
1485     if (verbose)
1486       AliInfo(Form("Equipment # %d (DDL # %d) data has been readed", currentEquipment, currentDDL));
1487
1488
1489     //set up the decoder
1490     fDecoder->SetVerbose(verbose);
1491     fDecoder->SetDataBuffer(&fDataBuffer[currentDDL]);
1492     fDecoder->SetPackedDataBuffer(&fPackedDataBuffer[currentDDL]);
1493
1494     //start decoding
1495     if (fDecoder->Decode((UInt_t *)data, kDataWords, currentCDH) == kTRUE) {
1496       fRawReader->AddMajorErrorLog(kDDLDecoder,Form("DDL # = %d",currentDDL));
1497       AliWarning(Form("Error while decoding DDL # %d: decoder returned with errors", currentDDL));
1498       ResetDataBuffer(currentDDL);
1499       ResetPackedDataBuffer(currentDDL);
1500     }
1501
1502     delete [] data;
1503     data = 0x0;
1504   }
1505
1506   //reset reader
1507   fRawReader->Reset();
1508
1509   if (verbose)
1510     AliInfo("All done");
1511
1512   return kFALSE;
1513
1514 }
1515 //-----------------------------------------------------------------------------
1516 Bool_t AliTOFRawStream::DecodeV2(Int_t verbose = 0) {
1517   //
1518   // Enhanced decoder method
1519   //
1520
1521   Int_t currentEquipment;
1522   Int_t currentDDL;
1523   //const AliRawDataHeader *currentCDH;
1524
1525   //pointers
1526   UChar_t *data = 0x0;
1527
1528   // read header
1529   if (!fRawReader->ReadHeader()) return kTRUE;
1530
1531   //get equipment infos
1532   currentEquipment = fRawReader->GetEquipmentId();
1533   currentDDL = fRawReader->GetDDLID();
1534   //currentCDH = fRawReader->GetDataHeader();
1535   const Int_t kDataSize = fRawReader->GetDataSize();
1536   const Int_t kDataWords = kDataSize / 4;
1537   data = new UChar_t[kDataSize];
1538
1539   if (verbose)
1540     AliInfo(Form("Found equipment # %d header (DDL # %d): %d bytes (%d words)", currentEquipment, currentDDL, kDataSize, kDataWords));
1541
1542   if (verbose)
1543     AliInfo(Form("Reading equipment #%d (DDL # %d) data...", currentEquipment, currentDDL));
1544
1545   //read equipment payload
1546   if (!fRawReader->ReadNext(data, kDataSize))
1547     {
1548       fRawReader->AddMajorErrorLog(kDDLdataReading);
1549       if (verbose)
1550         AliWarning("Error while reading DDL data. Go to next equipment");
1551       delete [] data;
1552       data = 0x0;
1553       return kTRUE;
1554     }
1555
1556   if (verbose)
1557     AliInfo(Form("Equipment # %d (DDL # %d) data has been read", currentEquipment, currentDDL));
1558
1559
1560   //set up the decoder
1561   fDecoderV2->SetVerbose(verbose);
1562
1563   //start decoding
1564   if (fDecoderV2->Decode((UInt_t *)data, kDataWords) == kTRUE) {
1565     fRawReader->AddMajorErrorLog(kDDLDecoder,Form("DDL # = %d",currentDDL));
1566     AliWarning(Form("Error while decoding DDL # %d: decoder returned with errors", currentDDL));
1567   }
1568
1569   delete [] data;
1570
1571   if (verbose)
1572     AliInfo("All done");
1573
1574   return kFALSE;
1575
1576 }
1577 //---------------------------------------------------------------------------
1578 void
1579 AliTOFRawStream::ResetBuffers()
1580 {
1581   //
1582   // To reset the buffers
1583   //
1584
1585   for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls("TOF"); iDDL++){
1586     ResetDataBuffer(iDDL);
1587     ResetPackedDataBuffer(iDDL);
1588   }
1589 }
1590
1591 //---------------------------------------------------------------------------
1592 Bool_t
1593 AliTOFRawStream::LoadRawDataBuffers(Int_t indexDDL, Int_t verbose)
1594 {
1595   //
1596   // To load the buffers
1597   //
1598
1599   fTOFrawData->Clear();
1600   fPackedDigits = 0;
1601
1602   if (verbose > 0)
1603     AliInfo(Form("Decoding raw data for DDL # %d ...", indexDDL));
1604
1605   if (DecodeDDL(indexDDL, indexDDL, verbose) != 0){ //decode DDL
1606     fRawReader->AddMajorErrorLog(kDDLDecoder,Form("DDL # = %d",indexDDL));
1607     AliWarning(Form("Error while decoding DDL # %d", indexDDL));
1608     return kTRUE;
1609   }
1610
1611   if (verbose > 0)
1612     AliInfo(Form("Done. %d packed %s been found.", fPackedDataBuffer[indexDDL].GetEntries(), fPackedDataBuffer[indexDDL].GetEntries() > 1 ? "hits have" : "hit has"));
1613
1614   AliTOFHitData *hitData; //hit data pointer
1615
1616   if (verbose > 0)
1617     AliInfo("Filling TClonesArray ...");
1618
1619   if (verbose > 0)
1620     if (fgApplyBCCorrections) {
1621       AliInfo("Apply nominal DDL BC time-shift correction");
1622       AliInfo("Apply deltaBC time-shift correction");
1623     }
1624
1625   //loop over DDL packed hits
1626   for (Int_t iHit = 0; iHit < fPackedDataBuffer[indexDDL].GetEntries(); iHit++){
1627     hitData = fPackedDataBuffer[indexDDL].GetHit(iHit); //get hit data
1628     Int_t   hitACQ = hitData->GetACQ();
1629     Int_t   hitPS = hitData->GetPS();
1630     Int_t   hitSlotID = hitData->GetSlotID();
1631     Int_t   hitChain = hitData->GetChain();
1632     Int_t   hitTDC = hitData->GetTDC();
1633     Int_t   hitChan = hitData->GetChan();
1634     Int_t   hitTimeBin = hitData->GetTimeBin();
1635     Int_t   hitTOTBin = hitData->GetTOTBin();
1636     Int_t   hitDeltaBC = hitData->GetDeltaBunchID();
1637     Int_t   hitL0L1Latency = hitData->GetL0L1Latency();
1638
1639     Int_t hitLeading = hitData->GetTimeBin();
1640     Int_t hitTrailing = -1;
1641     Int_t hitError = -1;
1642
1643     TClonesArray &arrayTofRawData =  *fTOFrawData;
1644     new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(hitSlotID, hitChain, hitTDC, hitChan, hitTimeBin, hitTOTBin, hitLeading, hitTrailing, hitPS, hitACQ, hitError, hitDeltaBC, hitL0L1Latency);
1645   }
1646
1647   if (verbose > 0)
1648     AliInfo("Done.");
1649
1650   if (verbose > 0)
1651     AliInfo("Resetting buffers ...");
1652
1653   fDataBuffer[indexDDL].Reset();
1654   fPackedDataBuffer[indexDDL].Reset();
1655
1656   if (verbose > 0)
1657     AliInfo("Done.");
1658
1659   return kFALSE;
1660 }
1661
1662 //---------------------------------------------------------------------------
1663 Bool_t
1664 AliTOFRawStream::LoadRawDataBuffersV2(Int_t indexDDL, Int_t verbose)
1665 {
1666   //
1667   // To load the buffers
1668   //
1669
1670   /*
1671    * decode raw data and fill output array with TOF hits.
1672    * decode algorithm may return with errors due to inconsistent
1673    * raw data format detected during decoding process.
1674    * decoder algorithm has internal recover procedure to deal with
1675    * errors in a safe condition.
1676    *
1677    * the following conditions will cause total hit rejection from
1678    * specific boards where the condition is detected:
1679    *
1680    * --- within DRM payload (full DRM skipped) ---
1681    * - no header/trailer detected
1682    *
1683    * --- within TRM payload (full TRM skippped) ---
1684    * - no header/trailer detected
1685    * - empty event inserted
1686    * - bad event counter
1687    * - bad CRC
1688    * - ACQ mode off
1689    *
1690    * --- within chain payload (full chain skipped) ---
1691    * - no header/trailer detected
1692    * - bad status
1693    * - bad event counter
1694    *
1695    * --- HPTDC (ful TDC skipped) ---
1696    * - error detected
1697    *
1698    */
1699
1700   fTOFrawData->Clear();
1701   fPackedDigits = 0;
1702
1703   if (verbose > 0)
1704     AliInfo(Form("Decoding raw data for DDL # %d ...", indexDDL));
1705
1706   //check and fix valid DDL range
1707   if (indexDDL < 0){
1708     indexDDL = 0;
1709     fRawReader->AddMinorErrorLog(kDDLMinError);
1710     AliWarning("Wrong DDL range: setting first DDL ID to 0");
1711   }
1712   if (indexDDL > 71){
1713     indexDDL = 71;
1714     fRawReader->AddMinorErrorLog(kDDLMaxError);
1715     AliWarning("Wrong DDL range: setting last DDL ID to 71");
1716   }
1717
1718   //select required DDLs
1719   fRawReader->Reset();
1720   fRawReader->Select("TOF", indexDDL, indexDDL);
1721
1722   /* decode */
1723   if (DecodeV2(verbose)) return kTRUE;
1724
1725   /* read and check CDH info */
1726   const AliRawDataHeader *currentCDH = fRawReader->GetDataHeader();
1727   Int_t currentMiniEventID = currentCDH->GetMiniEventID();
1728   Int_t currentEventID1 = currentCDH->GetEventID1();
1729
1730   /* read decoder summary data */
1731   AliTOFDecoderSummaryData *decodersd;
1732   AliTOFDRMSummaryData *drmsd;
1733   //  AliTOFLTMSummaryData *ltmsd;
1734   AliTOFTRMSummaryData *trmsd;
1735   AliTOFChainSummaryData *chainsd;
1736   AliTOFTDCHitBuffer *hitBuffer;
1737   AliTOFTDCHit *hit;
1738   AliTOFTDCErrorBuffer *errorBuffer;
1739   AliTOFTDCError *error;
1740   Bool_t tdcErrorFlag[15];
1741   decodersd = fDecoderV2->GetDecoderSummaryData();
1742
1743   /* check error detected/recovered */
1744   if (decodersd->GetErrorDetected()) {
1745     AliWarning(Form("Error detected while decoding DDL %d (errorSlotID mask = %04x)", indexDDL, decodersd->GetErrorSlotID()));
1746     if (decodersd->GetRecoveringError()) {
1747       AliWarning("Couldn't recover from error");
1748     }
1749     else {
1750       AliWarning("Error recovered, anyway something is probably lost");
1751     }
1752   }
1753   /* check DRM header/trailer */
1754   drmsd = decodersd->GetDRMSummaryData();
1755   if (!drmsd->GetHeader() || !drmsd->GetTrailer()) {
1756     AliWarning("DRM header/trailer missing, skip DDL");
1757     return kTRUE;
1758   }
1759   /* check partecipating mask */
1760   if (drmsd->GetPartecipatingSlotID() != drmsd->GetDecoderSlotEnableMask()) {
1761     AliWarning(Form("DRM slot enable mask differs from decoder slot enable mask (%08x != %08x) in DDL %d", drmsd->GetSlotEnableMask(), drmsd->GetDecoderSlotEnableMask(), indexDDL));
1762     for (Int_t ibit = 0; ibit < 11; ibit++)
1763       if ((drmsd->GetPartecipatingSlotID() & (0x1 << ibit)) && !(drmsd->GetDecoderSlotEnableMask() & (0x1 << ibit)))
1764         AliWarning(Form("readout slot %d data is missing in decoder", ibit + 2));
1765   }
1766
1767   /* get DRM data */
1768   Int_t currentL0BCID = drmsd->GetL0BCID();
1769
1770   /* loop over TRM to get hits */
1771   Int_t hitACQ, hitPS, hitSlotID, hitChain, hitTDC, hitChan, hitTimeBin, hitTOTBin, hitDeltaBC, hitL0L1Latency, hitLeading, hitTrailing, hitError;
1772   Int_t currentBunchID;
1773
1774   /* loop over TRMs */
1775   for (Int_t itrm = 0; itrm < 10; itrm++) {
1776     trmsd = drmsd->GetTRMSummaryData(itrm);
1777     /* check header/trailer */
1778     if (!trmsd->GetHeader() || !trmsd->GetTrailer()) continue;
1779     /* skip if TRM empty event detected */
1780     if (trmsd->GetEBit() != 0) continue;
1781     /* skip if bad TRM event counter detected */
1782     if (trmsd->GetEventCounter() != drmsd->GetLocalEventCounter()) continue;
1783     /* skip if bad TRM CRC detected */
1784     if (trmsd->GetEventCRC() != trmsd->GetDecoderCRC()) continue;
1785
1786     /* loop over chains */
1787     for (Int_t ichain = 0; ichain < 2; ichain++) {
1788       chainsd = trmsd->GetChainSummaryData(ichain);
1789     /* check header/trailer */
1790       if (!chainsd->GetHeader() || !chainsd->GetTrailer()) continue;
1791       /* skip if chain bad status detected */
1792       if (chainsd->GetStatus() != 0) continue;
1793       /* skip if bad chain event counter detected */
1794       if (chainsd->GetEventCounter() != drmsd->GetLocalEventCounter()) continue;
1795
1796       currentBunchID = chainsd->GetBunchID();
1797       hitBuffer = chainsd->GetTDCPackedHitBuffer();
1798       errorBuffer = chainsd->GetTDCErrorBuffer();
1799
1800       /* check TDC errors and set TDC error flag */
1801       for (Int_t itdc = 0; itdc < 15; itdc++) tdcErrorFlag[itdc] = kFALSE;
1802       for (Int_t ierr = 0; ierr < errorBuffer->GetEntries(); ierr++) {
1803         error = errorBuffer->GetError(ierr);
1804         tdcErrorFlag[error->GetTDCID()] = kTRUE;
1805       }
1806
1807       /* loop over hits */
1808       for (Int_t ihit = 0; ihit < hitBuffer->GetEntries(); ihit++) {
1809
1810         /* get hit */
1811         hit = hitBuffer->GetHit(ihit);
1812         /* skip hit if coming from a TDC with error detected */
1813         if (tdcErrorFlag[hit->GetTDCID()]) continue;
1814
1815         /* set info */
1816         hitACQ = trmsd->GetACQBits();
1817         hitPS = hit->GetPSBits();
1818         hitSlotID = trmsd->GetSlotID();
1819         hitChain = chainsd->GetChain();
1820         hitTDC = hit->GetTDCID();
1821         hitChan = hit->GetChan();
1822         hitTimeBin = hit->GetHitTime();
1823         hitTOTBin = hit->GetTOTWidth();
1824         hitDeltaBC = currentBunchID - currentEventID1;
1825         hitL0L1Latency = currentMiniEventID - currentL0BCID;
1826
1827         hitLeading = hitTimeBin;
1828         hitTrailing = -1;
1829         hitError = -1;
1830
1831         /* add hit */
1832         TClonesArray &arrayTofRawData =  *fTOFrawData;
1833         new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(hitSlotID, hitChain, hitTDC, hitChan, hitTimeBin, hitTOTBin, hitLeading, hitTrailing, hitPS, hitACQ, hitError, hitDeltaBC, hitL0L1Latency);
1834       }
1835     }
1836   }
1837
1838   return kFALSE;
1839 }
1840
1841 //---------------------------------------------------------------------------
1842 void AliTOFRawStream::Geant2EquipmentId(Int_t vol[], Int_t eqId[])
1843 {
1844   //
1845   // To convert:
1846   //      nSector number -vol[0]- (variable in [0,17])
1847   //      nPlate  number -vol[1]- (variable in [0, 5])
1848   //      nStrip  number -vol[2]- (variable in [0,14/18])
1849   //      nPadZ   number -vol[3]- (variable in [0, 1])
1850   //      nPadX   number -vol[4]- (variable in [0,47])
1851   // in:
1852   //      nDDL     -eqId[0]- (variable in [0;71]) -> number of the DDL
1853   //      nTRM     -eqId[1]- (variable in [3;12]) -> number of the TRM
1854   //      nTDC     -eqId[2]- (variable in [0;14]) -> number of the TDC
1855   //      nChain   -eqId[3]- (variable in [0; 1]) -> number of the chain
1856   //      nChannel -eqId[4]- (variable in [0; 8]) -> number of the channel
1857   //
1858
1859   eqId[0] = Geant2DDL(vol);
1860   eqId[1] = Geant2TRM(vol);
1861   eqId[2] = Geant2TDC(vol);
1862   eqId[3] = Geant2Chain(vol);
1863   eqId[4] = Geant2Channel(vol);
1864
1865 }
1866
1867 //---------------------------------------------------------------------------
1868 Int_t AliTOFRawStream::Geant2DDL(Int_t vol[])
1869 {
1870   //
1871   // To convert:
1872   //      nSector number -vol[0]- (variable in [0,17])
1873   //      nPlate  number -vol[1]- (variable in [0, 5])
1874   //      nStrip  number -vol[2]- (variable in [0,14/18])
1875   //      nPadZ   number -vol[3]- (variable in [0, 1])
1876   //      nPadX   number -vol[4]- (variable in [0,47])
1877   // in:
1878   //      nDDL   (variable in [0;71]) -> number of the DDL
1879   //
1880
1881
1882   Int_t iDDL = -1;
1883
1884   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
1885     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
1886     return iDDL;
1887   }
1888   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
1889     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
1890     return iDDL;
1891   }
1892   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
1893     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
1894     return iDDL;
1895   }
1896   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ())
1897     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
1898   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX())
1899     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
1900   if ( vol[3]>=AliTOFGeometry::NpadZ() ) {
1901     printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
1902     return iDDL;
1903   }
1904
1905   Int_t nSector = vol[0];
1906   Int_t nPlate  = vol[1];
1907   Int_t nStrip  = vol[2];
1908   Int_t nPadX   = vol[4];
1909
1910   if ( nPadX<24 && ( nPlate==0 || nPlate==1 || (nPlate==2 && nStrip<7) ) )
1911     iDDL = 0;
1912   else if ( nPadX>=24 && ( nPlate==0 || nPlate==1 || (nPlate==2 && nStrip<8) ) )
1913     iDDL = 1;
1914   else if ( nPadX>=24 && ( nPlate==3 || nPlate==4 || (nPlate==2 && nStrip>7) ) )
1915     iDDL = 2;
1916   else if ( nPadX<24 && ( nPlate==3 || nPlate==4 || (nPlate==2 && nStrip>6) ) )
1917     iDDL = 3;
1918
1919   return 4*nSector+iDDL;
1920
1921 }
1922
1923 //---------------------------------------------------------------------------
1924 Int_t AliTOFRawStream::Geant2TRM(Int_t vol[])
1925 {
1926   //
1927   // To convert:
1928   //      nSector number -vol[0]- (variable in [0,17])
1929   //      nPlate  number -vol[1]- (variable in [0, 5])
1930   //      nStrip  number -vol[2]- (variable in [0,14/18])
1931   //      nPadZ   number -vol[3]- (variable in [0, 1])
1932   //      nPadX   number -vol[4]- (variable in [0,47])
1933   // in:
1934   //      nTRM   (variable in [3;12]) -> number of the TRM slot
1935   //
1936
1937   Int_t nTRM = -1;
1938
1939   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
1940     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
1941     return nTRM;
1942   }
1943   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
1944     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
1945     return nTRM;
1946   }
1947   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
1948     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
1949     return nTRM;
1950   }
1951   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ()) {
1952     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
1953     return nTRM;
1954   }
1955   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX()) {
1956     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
1957     return nTRM;
1958   }
1959
1960   if ( vol[3]>=AliTOFGeometry::NpadZ() )
1961     {
1962       printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
1963       return nTRM;
1964     }
1965
1966   Int_t nPlate  = vol[1];
1967   Int_t nStrip  = vol[2];
1968
1969   Int_t iDDL = Geant2DDL(vol)%4;
1970
1971   switch (iDDL) {
1972
1973   case 0:
1974
1975     if (nPlate==0) {
1976       if (nStrip<= 4) nTRM =  4;
1977       else if (nStrip> 4 && nStrip<= 9) nTRM =  5;
1978       else if (nStrip> 9 && nStrip<=14) nTRM =  6;
1979       else if (nStrip>14) nTRM =  7;
1980     }
1981     else if (nPlate==1) {
1982       if (nStrip== 0) nTRM =  7;
1983       else if (nStrip> 0 && nStrip<= 5) nTRM =  8;
1984       else if (nStrip> 5 && nStrip<=10) nTRM =  9;
1985       else if (nStrip>10 && nStrip<=15) nTRM = 10;
1986       else if (nStrip>15) nTRM = 11;
1987     }
1988     else if (nPlate==2) {
1989       if (nStrip<= 1) nTRM = 11;
1990       else if (nStrip> 1 && nStrip< 7) nTRM = 12;
1991     }
1992
1993     break;
1994   case 1:
1995
1996     if (nPlate==0) {
1997       if (nStrip== 0) nTRM =  3;
1998       else if (nStrip> 0 && nStrip<= 5) nTRM =  4;
1999       else if (nStrip> 5 && nStrip<=10) nTRM =  5;
2000       else if (nStrip>10 && nStrip<=15) nTRM =  6;
2001       else if (nStrip>15) nTRM =  7;
2002     }
2003     else if (nPlate==1) {
2004       if (nStrip<=1) nTRM = 7;
2005       else if (nStrip> 1 && nStrip<= 6) nTRM =  8;
2006       else if (nStrip> 6 && nStrip<=11) nTRM =  9;
2007       else if (nStrip>11 && nStrip<=16) nTRM = 10;
2008       else if (nStrip>16) nTRM = 11;
2009     }
2010     else if (nPlate==2) {
2011       if (nStrip<= 2) nTRM = 11;
2012       else if (nStrip> 2 && nStrip<= 7) nTRM = 12;
2013     }
2014
2015     break;
2016   case 2:
2017
2018     if (nPlate==4) {
2019       if (nStrip>=14) nTRM =  4;
2020       else if (nStrip<14 && nStrip>= 9) nTRM =  5;
2021       else if (nStrip< 9 && nStrip>= 4) nTRM =  6;
2022       else if (nStrip< 4) nTRM =  7;
2023     }
2024     else if (nPlate==3) {
2025       if (nStrip==18) nTRM =  7;
2026       else if (nStrip<18 && nStrip>=13) nTRM =  8;
2027       else if (nStrip<13 && nStrip>= 8) nTRM =  9;
2028       else if (nStrip< 8 && nStrip>= 3) nTRM = 10;
2029       else if (nStrip< 3) nTRM = 11;
2030     }
2031     else if (nPlate==2) {
2032       if (nStrip>=13) nTRM = 11;
2033       else if (nStrip<13 && nStrip>= 8) nTRM = 12;
2034     }
2035
2036     break;
2037   case 3:
2038
2039     if (nPlate==4) {
2040       if (nStrip==18) nTRM =  3;
2041       else if (nStrip<18 && nStrip>=13) nTRM =  4;
2042       else if (nStrip<13 && nStrip>= 8) nTRM =  5;
2043       else if (nStrip< 8 && nStrip>= 3) nTRM =  6;
2044       else if (nStrip< 3) nTRM =  7;
2045     }
2046     else if (nPlate==3) {
2047       if (nStrip>=17) nTRM = 7;
2048       else if (nStrip<17 && nStrip>=12) nTRM =  8;
2049       else if (nStrip<12 && nStrip>= 7) nTRM =  9;
2050       else if (nStrip< 7 && nStrip>= 2) nTRM = 10;
2051       else if (nStrip< 2) nTRM = 11;
2052     }
2053     else if (nPlate==2) {
2054       if (nStrip>=12) nTRM = 11;
2055       else if (nStrip <12 && nStrip>= 7) nTRM = 12;
2056     }
2057
2058     break;
2059
2060   }
2061
2062   return nTRM;
2063
2064 }
2065
2066 //---------------------------------------------------------------------------
2067 Int_t AliTOFRawStream::Geant2TDC(Int_t vol[])
2068 {
2069   //
2070   // To convert:
2071   //      nSector number -vol[0]- (variable in [0,17])
2072   //      nPlate  number -vol[1]- (variable in [0, 5])
2073   //      nStrip  number -vol[2]- (variable in [0,14/18])
2074   //      nPadZ   number -vol[3]- (variable in [0, 1])
2075   //      nPadX   number -vol[4]- (variable in [0,47])
2076   // in:
2077   //      nTDC   (variable in [0;14]) -> number of the TDC
2078   //
2079
2080   Int_t nTDC = -1;
2081
2082   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
2083     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
2084     return nTDC;
2085   }
2086   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
2087     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
2088     return nTDC;
2089   }
2090   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
2091     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
2092     return nTDC;
2093   }
2094   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ())
2095     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
2096   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX())
2097     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
2098   if ( vol[3]>=AliTOFGeometry::NpadZ() ) {
2099     printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
2100     return nTDC;
2101   }
2102
2103   Int_t nPlate  = vol[1];
2104   Int_t nStrip  = vol[2];
2105   Int_t iPadX   = vol[4];
2106
2107   Int_t iDDL = Geant2DDL(vol)%4;
2108
2109   switch (iDDL) {
2110
2111   case 0:
2112
2113     if (nPlate==0) {
2114       if (nStrip<= 4) nTDC = (3*(nStrip)+2-(iPadX/4)%3);
2115       else if (nStrip> 4 && nStrip<= 9) nTDC = (3*(nStrip- 5)+2-(iPadX/4)%3);
2116       else if (nStrip> 9 && nStrip<=14) nTDC = (3*(nStrip-10)+2-(iPadX/4)%3);
2117       else if (nStrip>14) nTDC =  (3*(nStrip-15)+2-(iPadX/4)%3);
2118     }
2119     else if (nPlate==1) {
2120       if (nStrip== 0) nTDC =  (3*(nStrip+ 4)+2-(iPadX/4)%3);
2121       else if (nStrip> 0 && nStrip<= 5) nTDC = (3*(nStrip- 1)+2-(iPadX/4)%3);
2122       else if (nStrip> 5 && nStrip<=10) nTDC = (3*(nStrip- 6)+2-(iPadX/4)%3);
2123       else if (nStrip>10 && nStrip<=15) nTDC = (3*(nStrip-11)+2-(iPadX/4)%3);
2124       else if (nStrip>15) nTDC = (3*(nStrip-16)+2-(iPadX/4)%3);
2125     }
2126     else if (nPlate==2) {
2127       if (nStrip<= 1) nTDC = (3*(nStrip+ 3)+2-(iPadX/4)%3);
2128       else if (nStrip> 1 && nStrip< 7) nTDC = (3*(nStrip- 2)+2-(iPadX/4)%3);
2129     }
2130
2131     break;
2132   case 1:
2133
2134     if (nPlate==0) {
2135       if (nStrip== 0) nTDC = (3*(nStrip)+(iPadX/4)%3);
2136       else if (nStrip> 0 && nStrip<= 5) nTDC = (3*( 5-nStrip)+(iPadX/4)%3);
2137       else if (nStrip> 5 && nStrip<=10) nTDC = (3*(10-nStrip)+(iPadX/4)%3);
2138       else if (nStrip>10 && nStrip<=15) nTDC = (3*(15-nStrip)+(iPadX/4)%3);
2139       else if (nStrip>15) nTDC = (3*(20-nStrip)+(iPadX/4)%3);
2140     }
2141     else if (nPlate==1) {
2142       if (nStrip<= 1) nTDC = (3*( 1-nStrip)+(iPadX/4)%3);
2143       else if (nStrip> 1 && nStrip<= 6) nTDC = (3*( 6-nStrip)+(iPadX/4)%3);
2144       else if (nStrip> 6 && nStrip<=11) nTDC = (3*(11-nStrip)+(iPadX/4)%3);
2145       else if (nStrip>11 && nStrip<=16) nTDC = (3*(16-nStrip)+(iPadX/4)%3);
2146       else if (nStrip>16) nTDC = (3*(21-nStrip)+(iPadX/4)%3);
2147     }
2148     else if (nPlate==2) {
2149       if (nStrip<= 2) nTDC = (3*( 2-nStrip)+(iPadX/4)%3);
2150       else if (nStrip> 2 && nStrip<= 7) nTDC = (3*( 7-nStrip)+(iPadX/4)%3);
2151     }
2152
2153     break;
2154   case 2:
2155
2156     if (nPlate==4) {
2157       if (nStrip>=14) nTDC = (3*(18-nStrip)+((iPadX/4)%3));
2158       else if (nStrip<14 && nStrip>= 9) nTDC = (3*(13-nStrip)+((iPadX/4)%3));
2159       else if (nStrip< 9 && nStrip>= 4) nTDC = (3*( 8-nStrip)+((iPadX/4)%3));
2160       else if (nStrip< 4) nTDC = (3*( 3-nStrip)+((iPadX/4)%3));
2161     }
2162     else if (nPlate==3) {
2163       if (nStrip==18) nTDC = (3*(22-nStrip)+((iPadX/4)%3));
2164       else if (nStrip<18 && nStrip>=13) nTDC = (3*(17-nStrip)+((iPadX/4)%3));
2165       else if (nStrip<13 && nStrip>= 8) nTDC = (3*(12-nStrip)+((iPadX/4)%3));
2166       else if (nStrip< 8 && nStrip>= 3) nTDC = (3*( 7-nStrip)+((iPadX/4)%3));
2167       else if (nStrip< 3) nTDC = (3*( 2-nStrip)+((iPadX/4)%3));
2168     }
2169     else if (nPlate==2) {
2170       if (nStrip>=13) nTDC = (3*(17-nStrip)+((iPadX/4)%3));
2171       else if (nStrip<13 && nStrip>= 8) nTDC = (3*(12-nStrip)+((iPadX/4)%3));
2172     }
2173
2174     break;
2175   case 3:
2176
2177     if (nPlate==4) {
2178       if (nStrip==18) nTDC = (3*(nStrip-18)+2-(iPadX/4)%3);
2179       else if (nStrip<18 && nStrip>=13) nTDC = (3*(nStrip-13)+2-(iPadX/4)%3);
2180       else if (nStrip<13 && nStrip>= 8) nTDC = (3*(nStrip- 8)+2-(iPadX/4)%3);
2181       else if (nStrip< 8 && nStrip>= 3) nTDC = (3*(nStrip- 3)+2-(iPadX/4)%3);
2182       else if (nStrip< 3) nTDC = (3*(nStrip+ 2)+2-(iPadX/4)%3);
2183     }
2184     else if (nPlate==3) {
2185       if (nStrip>=17) nTDC = (3*(nStrip-17)+2-(iPadX/4)%3);
2186       else if (nStrip<17 && nStrip>=12) nTDC = (3*(nStrip-12)+2-(iPadX/4)%3);
2187       else if (nStrip<12 && nStrip>= 7) nTDC = (3*(nStrip- 7)+2-(iPadX/4)%3);
2188       else if (nStrip< 7 && nStrip>= 2) nTDC = (3*(nStrip- 2)+2-(iPadX/4)%3);
2189       else if (nStrip< 2) nTDC = (3*(nStrip+ 3)+2-(iPadX/4)%3);
2190     }
2191     else if (nPlate==2) {
2192       if (nStrip>=12) nTDC = (3*(nStrip-12)+2-(iPadX/4)%3);
2193       else if (nStrip <12 && nStrip>= 7) nTDC = (3*(nStrip- 7)+2-(iPadX/4)%3);
2194     }
2195
2196     break;
2197
2198   }
2199
2200   return nTDC;
2201
2202 }
2203
2204 //---------------------------------------------------------------------------
2205 Int_t AliTOFRawStream::Geant2Chain(Int_t vol[])
2206 {
2207   //
2208   // To convert:
2209   //      nSector number -vol[0]- (variable in [0,17])
2210   //      nPlate  number -vol[1]- (variable in [0, 5])
2211   //      nStrip  number -vol[2]- (variable in [0,14/18])
2212   //      nPadZ   number -vol[3]- (variable in [0, 1])
2213   //      nPadX   number -vol[4]- variable in [0,47])
2214   // in:
2215   //      nChain (variable in [0; 1]) -> number of the TRM chain
2216   //
2217
2218   Int_t nChain = -1;
2219
2220   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
2221     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
2222     return nChain;
2223   }
2224   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
2225     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
2226     return nChain;
2227   }
2228   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
2229     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
2230     return nChain;
2231   }
2232   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ())
2233     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
2234   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX())
2235     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
2236   if ( vol[3]>=AliTOFGeometry::NpadZ() ) {
2237     printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
2238     return nChain;
2239   }
2240
2241   Int_t iPadX = vol[4];
2242
2243   if (iPadX<12 || iPadX>=36) nChain = 0;
2244   else nChain = 1;
2245
2246   return nChain;
2247
2248 }
2249
2250 //---------------------------------------------------------------------------
2251 Int_t AliTOFRawStream::Geant2Channel(Int_t vol[])
2252 {
2253   //
2254   // To convert:
2255   //      nSector number -vol[0]- (variable in [0,17])
2256   //      nPlate  number -vol[1]- (variable in [0, 5])
2257   //      nStrip  number -vol[2]- (variable in [0,14/18])
2258   //      nPadZ   number -vol[3]- (variable in [0, 1])
2259   //      nPadX   number -vol[4]- (variable in [0,47])
2260   // in:
2261   //      nChannel (variable in [0; 7]) -> number of the TDC channel
2262   //
2263
2264   Int_t nChannel = -1;
2265
2266   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
2267     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
2268     return nChannel;
2269   }
2270   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
2271     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
2272     return nChannel;
2273   }
2274   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
2275     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
2276     return nChannel;
2277   }
2278   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ())
2279     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
2280   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX())
2281     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
2282   if ( vol[3]>=AliTOFGeometry::NpadZ() ) {
2283     printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
2284     return nChannel;
2285   }
2286
2287   Int_t iPadZ   = vol[3];
2288   Int_t iPadX   = vol[4];
2289
2290   Int_t iDDL = Geant2DDL(vol)%4;
2291
2292   switch (iDDL) {
2293
2294   case 0:
2295     nChannel = ((2*(23-iPadX) + (1-iPadZ)))%8;
2296     break;
2297   case 1:
2298     nChannel = ((2*(iPadX-24) + (iPadZ)))%8;
2299     break;
2300   case 2:
2301     nChannel = ((2*(iPadX-24) + (iPadZ)))%8;
2302     break;
2303   case 3:
2304     nChannel = ((2*(23-iPadX) + (1-iPadZ)))%8;
2305     break;
2306   }
2307
2308   return nChannel;
2309
2310 }
2311
2312 //____________________________________________________________________________
2313 void AliTOFRawStream::Raw2Digits(AliRawReader* rawReader, TClonesArray * const digitsArray)
2314 {
2315   //
2316   // Converts raw data to digits for TOF
2317   //
2318
2319   TStopwatch stopwatch;
2320   stopwatch.Start();
2321
2322   //TClonesArray *fDigits = new TClonesArray("AliTOFdigit", 4000);
2323   //digitsTree->Branch("TOF", &fDigits);
2324   TClonesArray &aDigits = *digitsArray;
2325
2326   Int_t inholes = 0;
2327
2328   Clear();
2329   SetRawReader(rawReader);
2330
2331   //ofstream ftxt;
2332   //if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
2333
2334   TClonesArray staticRawData("AliTOFrawData",10000);
2335   staticRawData.Clear();
2336   TClonesArray * clonesRawData = &staticRawData;
2337
2338   Int_t dummy = -1;
2339   Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
2340   Int_t digit[4];
2341
2342   const Int_t kMaxNumberOfTracksPerDigit = 3;
2343   Int_t tracks[kMaxNumberOfTracksPerDigit];
2344   for (Int_t ii=0; ii<kMaxNumberOfTracksPerDigit; ii++)
2345     tracks[ii] = -1;
2346   Int_t last = -1;
2347
2348   Int_t indexDDL = 0;
2349   Int_t iRawData = 0;
2350   AliTOFrawData *tofRawDatum = 0;
2351   for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
2352
2353     rawReader->Reset();
2354     if (fNewDecoderVersion) {
2355       AliInfo("Using New Decoder \n");
2356       LoadRawDataBuffers(indexDDL, 0);
2357     }
2358     else
2359       LoadRawData(indexDDL);
2360
2361     clonesRawData = GetRawData();
2362     if (clonesRawData->GetEntriesFast()!=0) AliInfo(Form(" TOF raw data number = %3d", clonesRawData->GetEntriesFast()));
2363     for (iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
2364
2365       tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
2366
2367       //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
2368       if (tofRawDatum->GetTOF()==-1) continue;
2369
2370       EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
2371                            tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
2372
2373       dummy = detectorIndex[3];
2374       detectorIndex[3] = detectorIndex[4];//padz
2375       detectorIndex[4] = dummy;//padx
2376
2377       digit[0] = tofRawDatum->GetTOF();
2378       digit[1] = tofRawDatum->GetTOT();
2379       digit[2] = tofRawDatum->GetTOT();
2380       digit[3] = -1;//tofRawDatum->GetTOF(); //tofND
2381
2382       dummy = detectorIndex[3];
2383       detectorIndex[3] = detectorIndex[4];//padx
2384       detectorIndex[4] = dummy;//padz
2385
2386       // Do not reconstruct anything in the holes
2387       if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
2388         if (detectorIndex[1]==2) { // plate with holes
2389           inholes++;
2390           continue;
2391         }
2392       }
2393
2394       last = digitsArray->GetEntriesFast();
2395       new (aDigits[last]) AliTOFdigit(tracks, detectorIndex, digit);
2396       /*
2397       if (fVerbose==2) {
2398         if (indexDDL<10) ftxt << "  " << indexDDL;
2399         else         ftxt << " " << indexDDL;
2400         if (tofRawDatum->GetTRM()<10) ftxt << "  " << tofRawDatum->GetTRM();
2401         else         ftxt << " " << tofRawDatum->GetTRM();
2402         ftxt << "  " << tofRawDatum->GetTRMchain();
2403         if (tofRawDatum->GetTDC()<10) ftxt << "  " << tofRawDatum->GetTDC();
2404         else         ftxt << " " << tofRawDatum->GetTDC();
2405         ftxt << "  " << tofRawDatum->GetTDCchannel();
2406
2407         if (detectorIndex[0]<10) ftxt  << "  ->  " << detectorIndex[0];
2408         else              ftxt  << "  -> " << detectorIndex[0];
2409         ftxt << "  " << detectorIndex[1];
2410         if (detectorIndex[2]<10) ftxt << "  " << detectorIndex[2];
2411         else              ftxt << " " << detectorIndex[2];
2412         ftxt << "  " << detectorIndex[4];
2413         if (detectorIndex[4]<10) ftxt << "  " << detectorIndex[3];
2414         else              ftxt << " " << detectorIndex[3];
2415
2416         if (digit[1]<10)ftxt << "        " << digit[1];
2417         else if (digit[1]>=10 && digit[1]<100) ftxt << "      " << digit[1];
2418         else ftxt << "      " << digit[1];
2419         if (digit[0]<10) ftxt << "      " << digit[0] << endl;
2420         else if (digit[0]>=10 && digit[0]<100)   ftxt << "    " << digit[0] << endl;
2421         else if (digit[0]>=100 && digit[0]<1000) ftxt << "    " << digit[0] << endl;
2422         else ftxt << "   " << digit[3] << endl;
2423       }
2424       */
2425       AliDebug(2, Form(" Raw data reading %2d -> %2d %1d %2d %1d %2d (%d, %d, %d)",
2426                        last,
2427                        detectorIndex[0], detectorIndex[1], detectorIndex[2], detectorIndex[4], detectorIndex[3],
2428                        digit[0], digit[1], digit[3]));
2429
2430       tofRawDatum = 0;
2431     } // loop on tofRawData array
2432
2433     clonesRawData->Clear();
2434
2435   } // DDL Loop
2436
2437   //if (fVerbose==2) ftxt.close();
2438
2439
2440   if (inholes) AliWarning(Form("Raw data in the TOF holes: %d",inholes));
2441
2442   Int_t nDigits = digitsArray->GetEntries();
2443   AliDebug(1, Form("Got %d TOF digits", nDigits));
2444   AliDebug(1, Form("Execution time to read TOF raw data and fill TOF digit tree : R:%.2fs C:%.2fs",
2445                    stopwatch.RealTime(),stopwatch.CpuTime()));
2446
2447 }
2448
2449 //____________________________________________________________________________
2450 void AliTOFRawStream::Raw2SDigits(AliRawReader* rawReader, TClonesArray * const sdigitsArray)
2451 {
2452   //
2453   // Converts raw data to sdigits for TOF
2454   //
2455
2456   TStopwatch stopwatch;
2457   stopwatch.Start();
2458
2459   Int_t inholes = 0;
2460
2461   //if(!GetLoader()->TreeS()) {MakeTree("S");  MakeBranch("S");}
2462   TClonesArray &aSDigits = *sdigitsArray;
2463
2464   Clear();
2465   SetRawReader(rawReader);
2466
2467   //ofstream ftxt;
2468   //if (fVerbose==2) ftxt.open("TOFsdigitsRead.txt",ios::app);
2469
2470   TClonesArray staticRawData("AliTOFrawData",10000);
2471   staticRawData.Clear();
2472   TClonesArray * clonesRawData = &staticRawData;
2473
2474   Int_t dummy = -1;
2475   Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
2476   Int_t digit[2];
2477   Int_t track = -1;
2478   Int_t last = -1;
2479
2480   Int_t indexDDL = 0;
2481   Int_t iRawData = 0;
2482   AliTOFrawData *tofRawDatum = 0;
2483   for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
2484
2485     rawReader->Reset();
2486     if (fNewDecoderVersion) {
2487       AliInfo("Using New Decoder \n");
2488       LoadRawDataBuffers(indexDDL, 0);
2489     }
2490     else
2491       LoadRawData(indexDDL);
2492
2493     clonesRawData = GetRawData();
2494     if (clonesRawData->GetEntriesFast()!=0) AliInfo(Form(" TOF raw data number = %3d", clonesRawData->GetEntriesFast()));
2495     for (iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
2496
2497       tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
2498
2499       //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
2500       if (tofRawDatum->GetTOF()==-1) continue;
2501
2502       EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
2503                            tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
2504
2505       dummy = detectorIndex[3];
2506       detectorIndex[3] = detectorIndex[4];//padz
2507       detectorIndex[4] = dummy;//padx
2508
2509       digit[0] = tofRawDatum->GetTOF();
2510       digit[1] = tofRawDatum->GetTOT();
2511
2512       dummy = detectorIndex[3];
2513       detectorIndex[3] = detectorIndex[4];//padx
2514       detectorIndex[4] = dummy;//padz
2515
2516       // Do not reconstruct anything in the holes
2517       if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
2518         if (detectorIndex[1]==2) { // plate with holes
2519           inholes++;
2520           continue;
2521         }
2522       }
2523
2524       last = sdigitsArray->GetEntriesFast();
2525       new (aSDigits[last]) AliTOFSDigit(track, detectorIndex, digit);
2526       /*
2527       if (fVerbose==2) {
2528         if (indexDDL<10) ftxt << "  " << indexDDL;
2529         else         ftxt << " " << indexDDL;
2530         if (tofRawDatum->GetTRM()<10) ftxt << "  " << tofRawDatum->GetTRM();
2531         else         ftxt << " " << tofRawDatum->GetTRM();
2532         ftxt << "  " << tofRawDatum->GetTRMchain();
2533         if (tofRawDatum->GetTDC()<10) ftxt << "  " << tofRawDatum->GetTDC();
2534         else         ftxt << " " << tofRawDatum->GetTDC();
2535         ftxt << "  " << tofRawDatum->GetTDCchannel();
2536
2537         if (detectorIndex[0]<10) ftxt  << "  ->  " << detectorIndex[0];
2538         else              ftxt  << "  -> " << detectorIndex[0];
2539         ftxt << "  " << detectorIndex[1];
2540         if (detectorIndex[2]<10) ftxt << "  " << detectorIndex[2];
2541         else              ftxt << " " << detectorIndex[2];
2542         ftxt << "  " << detectorIndex[4];
2543         if (detectorIndex[4]<10) ftxt << "  " << detectorIndex[3];
2544         else              ftxt << " " << detectorIndex[3];
2545
2546         if (digit[1]<10)ftxt << "        " << digit[1];
2547         else if (digit[1]>=10 && digit[1]<100) ftxt << "      " << digit[1];
2548         else ftxt << "      " << digit[1];
2549         if (digit[0]<10) ftxt << "      " << digit[0] << endl;
2550         else if (digit[0]>=10 && digit[0]<100)   ftxt << "    " << digit[0] << endl;
2551         else if (digit[0]>=100 && digit[0]<1000) ftxt << "    " << digit[0] << endl;
2552         else ftxt << "   " << digit[3] << endl;
2553       }
2554       */
2555       AliDebug(2, Form(" Raw data reading %2d -> %2d %1d %2d %1d %2d (%d, %d)",
2556                        last,
2557                        detectorIndex[0], detectorIndex[1], detectorIndex[2], detectorIndex[4], detectorIndex[3],
2558                        digit[0], digit[1]));
2559
2560       tofRawDatum = 0;
2561     } // while loop
2562
2563     clonesRawData->Clear();
2564
2565   } // DDL Loop
2566
2567   //if (fVerbose==2) ftxt.close();
2568
2569   if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
2570
2571   Int_t nSDigits = sdigitsArray->GetEntries();
2572   AliDebug(1, Form("Got %d TOF sdigits", nSDigits));
2573   AliDebug(1, Form("Execution time to read TOF raw data and fill TOF sdigit tree : R:%.2fs C:%.2fs",
2574                    stopwatch.RealTime(),stopwatch.CpuTime()));
2575
2576 }
2577
2578 void AliTOFRawStream::VolumeID2LTM(Int_t detind[],
2579                                    Int_t &iDDL,
2580                                    Int_t &iTRM,
2581                                    Int_t &iChain,
2582                                    Int_t &iTDC,
2583                                    Int_t &iChannel) const {
2584   //
2585   // To convert the TOF trigger macropad ID (i.e. detind)
2586   // into TOF OR signals equipment ID (i.e. iDDL, iTRM, iChain, iTDC, iChannel)
2587   //
2588
2589   const Int_t kFirstTDCnumber = 12;
2590
2591   iDDL=-1, iTRM = 3 , iChain=-1, iTDC=-1, iChannel=-1;
2592   if (detind[1]==0 || detind[1]==1 || (detind[1]==2 && detind[2]<=7)) {
2593     if (detind[4]<24)
2594       iDDL = detind[0]*4;
2595     else
2596       iDDL = detind[0]*4;
2597   }
2598   else {
2599     if (detind[4]<24)
2600       iDDL = detind[0]*4+2;
2601     else
2602       iDDL = detind[0]*4+2;
2603   }
2604
2605   iChain=fgkChainMap24[detind[1]][detind[2]];
2606   iTDC=(Int_t)(fgkChannelMap24[detind[1]][detind[2]]/8)+kFirstTDCnumber;
2607   iChannel=fgkChannelMap24[detind[1]][detind[2]]%8;
2608
2609 }
2610
2611 void AliTOFRawStream::LTM2VolumeID(Int_t iDDL,
2612                                    Int_t iTRM,
2613                                    Int_t iChain,
2614                                    Int_t iTDC,
2615                                    Int_t iChannel,
2616                                    Int_t detind0[], Int_t detind1[]) const {
2617   //
2618   // To convert the TOF OR signals equipment ID (i.e. iDDL, iTRM, iChain, iTDC, iChannel)
2619   // into TOF trigger macropad IDs (i.e. detind0 and detind1).
2620   // In general, a couple of neighbouring TOF semi-strip represents a TOF trigger macropad.
2621   //
2622
2623   const Int_t kFirstTDCnumber = 12;
2624
2625   Int_t iSector0=-1, iModule0=-1, iStrip0=-1, iPadX0=-1; // Le variabili del Volume ID
2626   Int_t iSector1=-1, iModule1=-1, iStrip1=-1, iPadX1=-1; // Le variabili del Volume ID
2627
2628   if( iDDL%2==1 && iTRM==3 && iTDC-kFirstTDCnumber>=0 && iTDC-kFirstTDCnumber<3 ) {
2629     iSector0 = (Int_t)(iDDL/4);
2630     iSector1 = (Int_t)(iDDL/4);
2631     Int_t iChan= iChannel+(iTDC-kFirstTDCnumber)*8;
2632     if( iDDL%4 == 1 ){
2633       if(iChain==0){      //CRATE 0
2634         iPadX0=0;
2635         iPadX1=0;
2636         iStrip0=fgkStrip0MapCrate0[iChan];
2637         iStrip1=fgkStrip1MapCrate0[iChan];
2638         iModule0=fgkModule0MapCrate0[iChan];
2639         iModule1=fgkModule1MapCrate0[iChan];
2640       }
2641       if(iChain==1){// CRATE 1
2642         iPadX0=24;
2643         iPadX1=24;
2644         iStrip0=fgkStrip0MapCrate1[iChan];
2645         iStrip1=fgkStrip1MapCrate1[iChan];
2646         iModule0=fgkModule0MapCrate1[iChan];
2647         iModule1=fgkModule1MapCrate1[iChan];
2648       }
2649
2650     }
2651     if( iDDL%4 == 3 ){
2652       if(iChain==1){// CRATE 3
2653         iPadX0=0;
2654         iPadX1=0;
2655         iStrip0=fgkStrip0MapCrate3[iChan];
2656         iStrip1=fgkStrip1MapCrate3[iChan];
2657         iModule0=fgkModule0MapCrate3[iChan];
2658         iModule1=fgkModule1MapCrate3[iChan];
2659       }
2660       if(iChain==0){// CRATE 2
2661         iPadX0=24;
2662         iPadX1=24;
2663         iStrip0=fgkStrip0MapCrate2[iChan];
2664         iStrip1=fgkStrip1MapCrate2[iChan];
2665         iModule0=fgkModule0MapCrate2[iChan];
2666         iModule1=fgkModule1MapCrate2[iChan];
2667       }
2668     }
2669   }
2670
2671   if(iStrip1==-1 || iModule1==-1){
2672     detind1[0]=-1;
2673     detind1[1]=-1;
2674     detind1[2]=-1;
2675     detind1[3]=-1;
2676     detind1[4]=-1;
2677   }
2678   else{
2679     detind1[0]=iSector1;
2680     detind1[1]=iModule1;
2681     detind1[2]=iStrip1;
2682     detind1[3]=iPadX1;
2683     detind1[4]=0;
2684   }
2685
2686   if(iStrip0==-1 || iModule0==-1){
2687     detind0[0]=-1;
2688     detind0[1]=-1;
2689     detind0[2]=-1;
2690     detind0[3]=-1;
2691     detind0[4]=-1;
2692   }
2693   else{
2694     detind0[0]=iSector0;
2695     detind0[1]=iModule0;
2696     detind0[2]=iStrip0;
2697     detind0[3]=iPadX0;
2698     detind0[4]=0;
2699   }
2700 }