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     //get equipment infos
1449     currentEquipment = fRawReader->GetEquipmentId();
1450
1451     currentDDL = fRawReader->GetDDLID();
1452     if (currentDDL==-1) {
1453       fRawReader->AddMajorErrorLog(kDDLdataReading);
1454       if (verbose)
1455         AliWarning("Error when load DDL. Go to next DDL");
1456       continue;
1457     }
1458
1459     currentCDH = fRawReader->GetDataHeader();
1460     const Int_t kDataSize = fRawReader->GetDataSize();
1461     const Int_t kDataWords = kDataSize / 4;
1462     data = new UChar_t[kDataSize];
1463
1464     if (verbose)
1465       AliInfo(Form("Found equipment # %d header (DDL # %d): %d bytes (%d words)", currentEquipment, currentDDL, kDataSize, kDataWords));
1466
1467     if (verbose)
1468       AliInfo(Form("Reading equipment #%d (DDL # %d) data...", currentEquipment, currentDDL));
1469
1470     //read equipment payload
1471     if (!fRawReader->ReadNext(data, kDataSize))
1472       {
1473         fRawReader->AddMajorErrorLog(kDDLdataReading);
1474         if (verbose)
1475           AliWarning("Error while reading DDL data. Go to next equipment");
1476         delete [] data;
1477         data = 0x0;
1478         continue;
1479       }
1480
1481     if (verbose)
1482       AliInfo(Form("Equipment # %d (DDL # %d) data has been readed", currentEquipment, currentDDL));
1483
1484
1485     //set up the decoder
1486     fDecoder->SetVerbose(verbose);
1487     fDecoder->SetDataBuffer(&fDataBuffer[currentDDL]);
1488     fDecoder->SetPackedDataBuffer(&fPackedDataBuffer[currentDDL]);
1489
1490     //start decoding
1491     if (fDecoder->Decode((UInt_t *)data, kDataWords, currentCDH) == kTRUE) {
1492       fRawReader->AddMajorErrorLog(kDDLDecoder,Form("DDL # = %d",currentDDL));
1493       AliWarning(Form("Error while decoding DDL # %d: decoder returned with errors", currentDDL));
1494       ResetDataBuffer(currentDDL);
1495       ResetPackedDataBuffer(currentDDL);
1496     }
1497
1498     delete [] data;
1499     data = 0x0;
1500   }
1501
1502   //reset reader
1503   fRawReader->Reset();
1504
1505   if (verbose)
1506     AliInfo("All done");
1507
1508   return kFALSE;
1509
1510 }
1511 //-----------------------------------------------------------------------------
1512 Bool_t AliTOFRawStream::DecodeV2(Int_t verbose = 0) {
1513   //
1514   // Enhanced decoder method
1515   //
1516
1517   Int_t currentEquipment;
1518   Int_t currentDDL;
1519   //const AliRawDataHeader *currentCDH;
1520
1521   //pointers
1522   UChar_t *data = 0x0;
1523
1524   // read header
1525   if (!fRawReader->ReadHeader()) return kTRUE;
1526
1527   //get equipment infos
1528   currentEquipment = fRawReader->GetEquipmentId();
1529   currentDDL = fRawReader->GetDDLID();
1530   //currentCDH = fRawReader->GetDataHeader();
1531   const Int_t kDataSize = fRawReader->GetDataSize();
1532   const Int_t kDataWords = kDataSize / 4;
1533   data = new UChar_t[kDataSize];
1534
1535   if (verbose)
1536     AliInfo(Form("Found equipment # %d header (DDL # %d): %d bytes (%d words)", currentEquipment, currentDDL, kDataSize, kDataWords));
1537
1538   if (verbose)
1539     AliInfo(Form("Reading equipment #%d (DDL # %d) data...", currentEquipment, currentDDL));
1540
1541   //read equipment payload
1542   if (!fRawReader->ReadNext(data, kDataSize))
1543     {
1544       fRawReader->AddMajorErrorLog(kDDLdataReading);
1545       if (verbose)
1546         AliWarning("Error while reading DDL data. Go to next equipment");
1547       delete [] data;
1548       data = 0x0;
1549       return kTRUE;
1550     }
1551
1552   if (verbose)
1553     AliInfo(Form("Equipment # %d (DDL # %d) data has been read", currentEquipment, currentDDL));
1554
1555
1556   //set up the decoder
1557   fDecoderV2->SetVerbose(verbose);
1558
1559   //start decoding
1560   if (fDecoderV2->Decode((UInt_t *)data, kDataWords) == kTRUE) {
1561     fRawReader->AddMajorErrorLog(kDDLDecoder,Form("DDL # = %d",currentDDL));
1562     AliWarning(Form("Error while decoding DDL # %d: decoder returned with errors", currentDDL));
1563   }
1564
1565   delete [] data;
1566
1567   if (verbose)
1568     AliInfo("All done");
1569
1570   return kFALSE;
1571
1572 }
1573 //---------------------------------------------------------------------------
1574 void
1575 AliTOFRawStream::ResetBuffers()
1576 {
1577   //
1578   // To reset the buffers
1579   //
1580
1581   for (Int_t iDDL = 0; iDDL < AliDAQ::NumberOfDdls("TOF"); iDDL++){
1582     ResetDataBuffer(iDDL);
1583     ResetPackedDataBuffer(iDDL);
1584   }
1585 }
1586
1587 //---------------------------------------------------------------------------
1588 Bool_t
1589 AliTOFRawStream::LoadRawDataBuffers(Int_t indexDDL, Int_t verbose)
1590 {
1591   //
1592   // To load the buffers
1593   //
1594
1595   fTOFrawData->Clear();
1596   fPackedDigits = 0;
1597
1598   if (verbose > 0)
1599     AliInfo(Form("Decoding raw data for DDL # %d ...", indexDDL));
1600
1601   if (DecodeDDL(indexDDL, indexDDL, verbose) != 0){ //decode DDL
1602     fRawReader->AddMajorErrorLog(kDDLDecoder,Form("DDL # = %d",indexDDL));
1603     AliWarning(Form("Error while decoding DDL # %d", indexDDL));
1604     return kTRUE;
1605   }
1606
1607   if (verbose > 0)
1608     AliInfo(Form("Done. %d packed %s been found.", fPackedDataBuffer[indexDDL].GetEntries(), fPackedDataBuffer[indexDDL].GetEntries() > 1 ? "hits have" : "hit has"));
1609
1610   AliTOFHitData *hitData; //hit data pointer
1611
1612   if (verbose > 0)
1613     AliInfo("Filling TClonesArray ...");
1614
1615   if (verbose > 0)
1616     if (fgApplyBCCorrections) {
1617       AliInfo("Apply nominal DDL BC time-shift correction");
1618       AliInfo("Apply deltaBC time-shift correction");
1619     }
1620
1621   //loop over DDL packed hits
1622   for (Int_t iHit = 0; iHit < fPackedDataBuffer[indexDDL].GetEntries(); iHit++){
1623     hitData = fPackedDataBuffer[indexDDL].GetHit(iHit); //get hit data
1624     Int_t   hitACQ = hitData->GetACQ();
1625     Int_t   hitPS = hitData->GetPS();
1626     Int_t   hitSlotID = hitData->GetSlotID();
1627     Int_t   hitChain = hitData->GetChain();
1628     Int_t   hitTDC = hitData->GetTDC();
1629     Int_t   hitChan = hitData->GetChan();
1630     Int_t   hitTimeBin = hitData->GetTimeBin();
1631     Int_t   hitTOTBin = hitData->GetTOTBin();
1632     Int_t   hitDeltaBC = hitData->GetDeltaBunchID();
1633     Int_t   hitL0L1Latency = hitData->GetL0L1Latency();
1634
1635     Int_t hitLeading = hitData->GetTimeBin();
1636     Int_t hitTrailing = -1;
1637     Int_t hitError = -1;
1638
1639     TClonesArray &arrayTofRawData =  *fTOFrawData;
1640     new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(hitSlotID, hitChain, hitTDC, hitChan, hitTimeBin, hitTOTBin, hitLeading, hitTrailing, hitPS, hitACQ, hitError, hitDeltaBC, hitL0L1Latency);
1641   }
1642
1643   if (verbose > 0)
1644     AliInfo("Done.");
1645
1646   if (verbose > 0)
1647     AliInfo("Resetting buffers ...");
1648
1649   fDataBuffer[indexDDL].Reset();
1650   fPackedDataBuffer[indexDDL].Reset();
1651
1652   if (verbose > 0)
1653     AliInfo("Done.");
1654
1655   return kFALSE;
1656 }
1657
1658 //---------------------------------------------------------------------------
1659 Bool_t
1660 AliTOFRawStream::LoadRawDataBuffersV2(Int_t indexDDL, Int_t verbose)
1661 {
1662   //
1663   // To load the buffers
1664   //
1665
1666   /*
1667    * decode raw data and fill output array with TOF hits.
1668    * decode algorithm may return with errors due to inconsistent
1669    * raw data format detected during decoding process.
1670    * decoder algorithm has internal recover procedure to deal with
1671    * errors in a safe condition.
1672    *
1673    * the following conditions will cause total hit rejection from
1674    * specific boards where the condition is detected:
1675    *
1676    * --- within DRM payload (full DRM skipped) ---
1677    * - no header/trailer detected
1678    *
1679    * --- within TRM payload (full TRM skippped) ---
1680    * - no header/trailer detected
1681    * - empty event inserted
1682    * - bad event counter
1683    * - bad CRC
1684    * - ACQ mode off
1685    *
1686    * --- within chain payload (full chain skipped) ---
1687    * - no header/trailer detected
1688    * - bad status
1689    * - bad event counter
1690    *
1691    * --- HPTDC (ful TDC skipped) ---
1692    * - error detected
1693    *
1694    */
1695
1696   fTOFrawData->Clear();
1697   fPackedDigits = 0;
1698
1699   if (verbose > 0)
1700     AliInfo(Form("Decoding raw data for DDL # %d ...", indexDDL));
1701
1702   //check and fix valid DDL range
1703   if (indexDDL < 0){
1704     indexDDL = 0;
1705     fRawReader->AddMinorErrorLog(kDDLMinError);
1706     AliWarning("Wrong DDL range: setting first DDL ID to 0");
1707   }
1708   if (indexDDL > 71){
1709     indexDDL = 71;
1710     fRawReader->AddMinorErrorLog(kDDLMaxError);
1711     AliWarning("Wrong DDL range: setting last DDL ID to 71");
1712   }
1713
1714   //select required DDLs
1715   fRawReader->Reset();
1716   fRawReader->Select("TOF", indexDDL, indexDDL);
1717
1718   /* decode */
1719   if (DecodeV2(verbose)) return kTRUE;
1720
1721   /* read and check CDH info */
1722   const AliRawDataHeader *currentCDH = fRawReader->GetDataHeader();
1723   Int_t currentMiniEventID = currentCDH->GetMiniEventID();
1724   Int_t currentEventID1 = currentCDH->GetEventID1();
1725
1726   /* read decoder summary data */
1727   AliTOFDecoderSummaryData *decodersd;
1728   AliTOFDRMSummaryData *drmsd;
1729   //  AliTOFLTMSummaryData *ltmsd;
1730   AliTOFTRMSummaryData *trmsd;
1731   AliTOFChainSummaryData *chainsd;
1732   AliTOFTDCHitBuffer *hitBuffer;
1733   AliTOFTDCHit *hit;
1734   AliTOFTDCErrorBuffer *errorBuffer;
1735   AliTOFTDCError *error;
1736   Bool_t tdcErrorFlag[15];
1737   decodersd = fDecoderV2->GetDecoderSummaryData();
1738
1739   /* check error detected/recovered */
1740   if (decodersd->GetErrorDetected()) {
1741     AliWarning(Form("Error detected while decoding DDL %d (errorSlotID mask = %04x)", indexDDL, decodersd->GetErrorSlotID()));
1742     if (decodersd->GetRecoveringError()) {
1743       AliWarning("Couldn't recover from error");
1744     }
1745     else {
1746       AliWarning("Error recovered, anyway something is probably lost");
1747     }
1748   }
1749   /* check DRM header/trailer */
1750   drmsd = decodersd->GetDRMSummaryData();
1751   if (!drmsd->GetHeader() || !drmsd->GetTrailer()) {
1752     AliWarning("DRM header/trailer missing, skip DDL");
1753     return kTRUE;
1754   }
1755   /* check partecipating mask */
1756   if (drmsd->GetPartecipatingSlotID() != drmsd->GetDecoderSlotEnableMask()) {
1757     AliWarning(Form("DRM slot enable mask differs from decoder slot enable mask (%08x != %08x) in DDL %d", drmsd->GetSlotEnableMask(), drmsd->GetDecoderSlotEnableMask(), indexDDL));
1758     for (Int_t ibit = 0; ibit < 11; ibit++)
1759       if ((drmsd->GetPartecipatingSlotID() & (0x1 << ibit)) && !(drmsd->GetDecoderSlotEnableMask() & (0x1 << ibit)))
1760         AliWarning(Form("readout slot %d data is missing in decoder", ibit + 2));
1761   }
1762
1763   /* get DRM data */
1764   Int_t currentL0BCID = drmsd->GetL0BCID();
1765
1766   /* loop over TRM to get hits */
1767   Int_t hitACQ, hitPS, hitSlotID, hitChain, hitTDC, hitChan, hitTimeBin, hitTOTBin, hitDeltaBC, hitL0L1Latency, hitLeading, hitTrailing, hitError;
1768   Int_t currentBunchID;
1769
1770   /* loop over TRMs */
1771   for (Int_t itrm = 0; itrm < 10; itrm++) {
1772     trmsd = drmsd->GetTRMSummaryData(itrm);
1773     /* check header/trailer */
1774     if (!trmsd->GetHeader() || !trmsd->GetTrailer()) continue;
1775     /* skip if TRM empty event detected */
1776     if (trmsd->GetEBit() != 0) continue;
1777     /* skip if bad TRM event counter detected */
1778     if (trmsd->GetEventCounter() != drmsd->GetLocalEventCounter()) continue;
1779     /* skip if bad TRM CRC detected */
1780     AliDebug(2,Form("~~~~~~ %02d %02d --- TRM CRC: as written in raw data =%d and as computed =%d ~~~~~~",indexDDL,itrm,trmsd->GetEventCRC(), trmsd->GetDecoderCRC()));
1781     if (trmsd->GetEventCRC() != trmsd->GetDecoderCRC()) continue;
1782
1783     /* loop over chains */
1784     for (Int_t ichain = 0; ichain < 2; ichain++) {
1785       chainsd = trmsd->GetChainSummaryData(ichain);
1786     /* check header/trailer */
1787       if (!chainsd->GetHeader() || !chainsd->GetTrailer()) continue;
1788       /* skip if chain bad status detected */
1789       if (chainsd->GetStatus() != 0) continue;
1790       /* skip if bad chain event counter detected */
1791       if (chainsd->GetEventCounter() != drmsd->GetLocalEventCounter()) continue;
1792
1793       currentBunchID = chainsd->GetBunchID();
1794       hitBuffer = chainsd->GetTDCPackedHitBuffer();
1795       errorBuffer = chainsd->GetTDCErrorBuffer();
1796
1797       /* check TDC errors and set TDC error flag */
1798       for (Int_t itdc = 0; itdc < 15; itdc++) tdcErrorFlag[itdc] = kFALSE;
1799       for (Int_t ierr = 0; ierr < errorBuffer->GetEntries(); ierr++) {
1800         error = errorBuffer->GetError(ierr);
1801         tdcErrorFlag[error->GetTDCID()] = kTRUE;
1802       }
1803
1804       /* loop over hits */
1805       for (Int_t ihit = 0; ihit < hitBuffer->GetEntries(); ihit++) {
1806
1807         /* get hit */
1808         hit = hitBuffer->GetHit(ihit);
1809         /* skip hit if coming from a TDC with error detected */
1810         if (tdcErrorFlag[hit->GetTDCID()]) continue;
1811
1812         /* set info */
1813         hitACQ = trmsd->GetACQBits();
1814         hitPS = hit->GetPSBits();
1815         hitSlotID = trmsd->GetSlotID();
1816         hitChain = chainsd->GetChain();
1817         hitTDC = hit->GetTDCID();
1818         hitChan = hit->GetChan();
1819         hitTimeBin = hit->GetHitTime();
1820         hitTOTBin = hit->GetTOTWidth();
1821         hitDeltaBC = currentBunchID - currentEventID1;
1822         hitL0L1Latency = currentMiniEventID - currentL0BCID;
1823
1824         hitLeading = hitTimeBin;
1825         hitTrailing = -1;
1826         hitError = -1;
1827
1828         /* add hit */
1829         TClonesArray &arrayTofRawData =  *fTOFrawData;
1830         new (arrayTofRawData[fPackedDigits++]) AliTOFrawData(hitSlotID, hitChain, hitTDC, hitChan, hitTimeBin, hitTOTBin, hitLeading, hitTrailing, hitPS, hitACQ, hitError, hitDeltaBC, hitL0L1Latency);
1831       }
1832     }
1833   }
1834
1835   return kFALSE;
1836 }
1837
1838 //---------------------------------------------------------------------------
1839 void AliTOFRawStream::Geant2EquipmentId(Int_t vol[], Int_t eqId[])
1840 {
1841   //
1842   // To convert:
1843   //      nSector number -vol[0]- (variable in [0,17])
1844   //      nPlate  number -vol[1]- (variable in [0, 5])
1845   //      nStrip  number -vol[2]- (variable in [0,14/18])
1846   //      nPadZ   number -vol[3]- (variable in [0, 1])
1847   //      nPadX   number -vol[4]- (variable in [0,47])
1848   // in:
1849   //      nDDL     -eqId[0]- (variable in [0;71]) -> number of the DDL
1850   //      nTRM     -eqId[1]- (variable in [3;12]) -> number of the TRM
1851   //      nTDC     -eqId[2]- (variable in [0;14]) -> number of the TDC
1852   //      nChain   -eqId[3]- (variable in [0; 1]) -> number of the chain
1853   //      nChannel -eqId[4]- (variable in [0; 8]) -> number of the channel
1854   //
1855
1856   eqId[0] = Geant2DDL(vol);
1857   eqId[1] = Geant2TRM(vol);
1858   eqId[2] = Geant2TDC(vol);
1859   eqId[3] = Geant2Chain(vol);
1860   eqId[4] = Geant2Channel(vol);
1861
1862 }
1863
1864 //---------------------------------------------------------------------------
1865 Int_t AliTOFRawStream::Geant2DDL(Int_t vol[])
1866 {
1867   //
1868   // To convert:
1869   //      nSector number -vol[0]- (variable in [0,17])
1870   //      nPlate  number -vol[1]- (variable in [0, 5])
1871   //      nStrip  number -vol[2]- (variable in [0,14/18])
1872   //      nPadZ   number -vol[3]- (variable in [0, 1])
1873   //      nPadX   number -vol[4]- (variable in [0,47])
1874   // in:
1875   //      nDDL   (variable in [0;71]) -> number of the DDL
1876   //
1877
1878
1879   Int_t iDDL = -1;
1880
1881   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
1882     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
1883     return iDDL;
1884   }
1885   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
1886     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
1887     return iDDL;
1888   }
1889   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
1890     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
1891     return iDDL;
1892   }
1893   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ())
1894     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
1895   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX())
1896     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
1897   if ( vol[3]>=AliTOFGeometry::NpadZ() ) {
1898     printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
1899     return iDDL;
1900   }
1901
1902   Int_t nSector = vol[0];
1903   Int_t nPlate  = vol[1];
1904   Int_t nStrip  = vol[2];
1905   Int_t nPadX   = vol[4];
1906
1907   if ( nPadX<24 && ( nPlate==0 || nPlate==1 || (nPlate==2 && nStrip<7) ) )
1908     iDDL = 0;
1909   else if ( nPadX>=24 && ( nPlate==0 || nPlate==1 || (nPlate==2 && nStrip<8) ) )
1910     iDDL = 1;
1911   else if ( nPadX>=24 && ( nPlate==3 || nPlate==4 || (nPlate==2 && nStrip>7) ) )
1912     iDDL = 2;
1913   else if ( nPadX<24 && ( nPlate==3 || nPlate==4 || (nPlate==2 && nStrip>6) ) )
1914     iDDL = 3;
1915
1916   return 4*nSector+iDDL;
1917
1918 }
1919
1920 //---------------------------------------------------------------------------
1921 Int_t AliTOFRawStream::Geant2TRM(Int_t vol[])
1922 {
1923   //
1924   // To convert:
1925   //      nSector number -vol[0]- (variable in [0,17])
1926   //      nPlate  number -vol[1]- (variable in [0, 5])
1927   //      nStrip  number -vol[2]- (variable in [0,14/18])
1928   //      nPadZ   number -vol[3]- (variable in [0, 1])
1929   //      nPadX   number -vol[4]- (variable in [0,47])
1930   // in:
1931   //      nTRM   (variable in [3;12]) -> number of the TRM slot
1932   //
1933
1934   Int_t nTRM = -1;
1935
1936   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
1937     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
1938     return nTRM;
1939   }
1940   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
1941     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
1942     return nTRM;
1943   }
1944   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
1945     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
1946     return nTRM;
1947   }
1948   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ()) {
1949     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
1950     return nTRM;
1951   }
1952   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX()) {
1953     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
1954     return nTRM;
1955   }
1956
1957   if ( vol[3]>=AliTOFGeometry::NpadZ() )
1958     {
1959       printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
1960       return nTRM;
1961     }
1962
1963   Int_t nPlate  = vol[1];
1964   Int_t nStrip  = vol[2];
1965
1966   Int_t iDDL = Geant2DDL(vol)%4;
1967
1968   switch (iDDL) {
1969
1970   case 0:
1971
1972     if (nPlate==0) {
1973       if (nStrip<= 4) nTRM =  4;
1974       else if (nStrip> 4 && nStrip<= 9) nTRM =  5;
1975       else if (nStrip> 9 && nStrip<=14) nTRM =  6;
1976       else if (nStrip>14) nTRM =  7;
1977     }
1978     else if (nPlate==1) {
1979       if (nStrip== 0) nTRM =  7;
1980       else if (nStrip> 0 && nStrip<= 5) nTRM =  8;
1981       else if (nStrip> 5 && nStrip<=10) nTRM =  9;
1982       else if (nStrip>10 && nStrip<=15) nTRM = 10;
1983       else if (nStrip>15) nTRM = 11;
1984     }
1985     else if (nPlate==2) {
1986       if (nStrip<= 1) nTRM = 11;
1987       else if (nStrip> 1 && nStrip< 7) nTRM = 12;
1988     }
1989
1990     break;
1991   case 1:
1992
1993     if (nPlate==0) {
1994       if (nStrip== 0) nTRM =  3;
1995       else if (nStrip> 0 && nStrip<= 5) nTRM =  4;
1996       else if (nStrip> 5 && nStrip<=10) nTRM =  5;
1997       else if (nStrip>10 && nStrip<=15) nTRM =  6;
1998       else if (nStrip>15) nTRM =  7;
1999     }
2000     else if (nPlate==1) {
2001       if (nStrip<=1) nTRM = 7;
2002       else if (nStrip> 1 && nStrip<= 6) nTRM =  8;
2003       else if (nStrip> 6 && nStrip<=11) nTRM =  9;
2004       else if (nStrip>11 && nStrip<=16) nTRM = 10;
2005       else if (nStrip>16) nTRM = 11;
2006     }
2007     else if (nPlate==2) {
2008       if (nStrip<= 2) nTRM = 11;
2009       else if (nStrip> 2 && nStrip<= 7) nTRM = 12;
2010     }
2011
2012     break;
2013   case 2:
2014
2015     if (nPlate==4) {
2016       if (nStrip>=14) nTRM =  4;
2017       else if (nStrip<14 && nStrip>= 9) nTRM =  5;
2018       else if (nStrip< 9 && nStrip>= 4) nTRM =  6;
2019       else if (nStrip< 4) nTRM =  7;
2020     }
2021     else if (nPlate==3) {
2022       if (nStrip==18) nTRM =  7;
2023       else if (nStrip<18 && nStrip>=13) nTRM =  8;
2024       else if (nStrip<13 && nStrip>= 8) nTRM =  9;
2025       else if (nStrip< 8 && nStrip>= 3) nTRM = 10;
2026       else if (nStrip< 3) nTRM = 11;
2027     }
2028     else if (nPlate==2) {
2029       if (nStrip>=13) nTRM = 11;
2030       else if (nStrip<13 && nStrip>= 8) nTRM = 12;
2031     }
2032
2033     break;
2034   case 3:
2035
2036     if (nPlate==4) {
2037       if (nStrip==18) nTRM =  3;
2038       else if (nStrip<18 && nStrip>=13) nTRM =  4;
2039       else if (nStrip<13 && nStrip>= 8) nTRM =  5;
2040       else if (nStrip< 8 && nStrip>= 3) nTRM =  6;
2041       else if (nStrip< 3) nTRM =  7;
2042     }
2043     else if (nPlate==3) {
2044       if (nStrip>=17) nTRM = 7;
2045       else if (nStrip<17 && nStrip>=12) nTRM =  8;
2046       else if (nStrip<12 && nStrip>= 7) nTRM =  9;
2047       else if (nStrip< 7 && nStrip>= 2) nTRM = 10;
2048       else if (nStrip< 2) nTRM = 11;
2049     }
2050     else if (nPlate==2) {
2051       if (nStrip>=12) nTRM = 11;
2052       else if (nStrip <12 && nStrip>= 7) nTRM = 12;
2053     }
2054
2055     break;
2056
2057   }
2058
2059   return nTRM;
2060
2061 }
2062
2063 //---------------------------------------------------------------------------
2064 Int_t AliTOFRawStream::Geant2TDC(Int_t vol[])
2065 {
2066   //
2067   // To convert:
2068   //      nSector number -vol[0]- (variable in [0,17])
2069   //      nPlate  number -vol[1]- (variable in [0, 5])
2070   //      nStrip  number -vol[2]- (variable in [0,14/18])
2071   //      nPadZ   number -vol[3]- (variable in [0, 1])
2072   //      nPadX   number -vol[4]- (variable in [0,47])
2073   // in:
2074   //      nTDC   (variable in [0;14]) -> number of the TDC
2075   //
2076
2077   Int_t nTDC = -1;
2078
2079   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
2080     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
2081     return nTDC;
2082   }
2083   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
2084     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
2085     return nTDC;
2086   }
2087   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
2088     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
2089     return nTDC;
2090   }
2091   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ())
2092     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
2093   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX())
2094     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
2095   if ( vol[3]>=AliTOFGeometry::NpadZ() ) {
2096     printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
2097     return nTDC;
2098   }
2099
2100   Int_t nPlate  = vol[1];
2101   Int_t nStrip  = vol[2];
2102   Int_t iPadX   = vol[4];
2103
2104   Int_t iDDL = Geant2DDL(vol)%4;
2105
2106   switch (iDDL) {
2107
2108   case 0:
2109
2110     if (nPlate==0) {
2111       if (nStrip<= 4) nTDC = (3*(nStrip)+2-(iPadX/4)%3);
2112       else if (nStrip> 4 && nStrip<= 9) nTDC = (3*(nStrip- 5)+2-(iPadX/4)%3);
2113       else if (nStrip> 9 && nStrip<=14) nTDC = (3*(nStrip-10)+2-(iPadX/4)%3);
2114       else if (nStrip>14) nTDC =  (3*(nStrip-15)+2-(iPadX/4)%3);
2115     }
2116     else if (nPlate==1) {
2117       if (nStrip== 0) nTDC =  (3*(nStrip+ 4)+2-(iPadX/4)%3);
2118       else if (nStrip> 0 && nStrip<= 5) nTDC = (3*(nStrip- 1)+2-(iPadX/4)%3);
2119       else if (nStrip> 5 && nStrip<=10) nTDC = (3*(nStrip- 6)+2-(iPadX/4)%3);
2120       else if (nStrip>10 && nStrip<=15) nTDC = (3*(nStrip-11)+2-(iPadX/4)%3);
2121       else if (nStrip>15) nTDC = (3*(nStrip-16)+2-(iPadX/4)%3);
2122     }
2123     else if (nPlate==2) {
2124       if (nStrip<= 1) nTDC = (3*(nStrip+ 3)+2-(iPadX/4)%3);
2125       else if (nStrip> 1 && nStrip< 7) nTDC = (3*(nStrip- 2)+2-(iPadX/4)%3);
2126     }
2127
2128     break;
2129   case 1:
2130
2131     if (nPlate==0) {
2132       if (nStrip== 0) nTDC = (3*(nStrip)+(iPadX/4)%3);
2133       else if (nStrip> 0 && nStrip<= 5) nTDC = (3*( 5-nStrip)+(iPadX/4)%3);
2134       else if (nStrip> 5 && nStrip<=10) nTDC = (3*(10-nStrip)+(iPadX/4)%3);
2135       else if (nStrip>10 && nStrip<=15) nTDC = (3*(15-nStrip)+(iPadX/4)%3);
2136       else if (nStrip>15) nTDC = (3*(20-nStrip)+(iPadX/4)%3);
2137     }
2138     else if (nPlate==1) {
2139       if (nStrip<= 1) nTDC = (3*( 1-nStrip)+(iPadX/4)%3);
2140       else if (nStrip> 1 && nStrip<= 6) nTDC = (3*( 6-nStrip)+(iPadX/4)%3);
2141       else if (nStrip> 6 && nStrip<=11) nTDC = (3*(11-nStrip)+(iPadX/4)%3);
2142       else if (nStrip>11 && nStrip<=16) nTDC = (3*(16-nStrip)+(iPadX/4)%3);
2143       else if (nStrip>16) nTDC = (3*(21-nStrip)+(iPadX/4)%3);
2144     }
2145     else if (nPlate==2) {
2146       if (nStrip<= 2) nTDC = (3*( 2-nStrip)+(iPadX/4)%3);
2147       else if (nStrip> 2 && nStrip<= 7) nTDC = (3*( 7-nStrip)+(iPadX/4)%3);
2148     }
2149
2150     break;
2151   case 2:
2152
2153     if (nPlate==4) {
2154       if (nStrip>=14) nTDC = (3*(18-nStrip)+((iPadX/4)%3));
2155       else if (nStrip<14 && nStrip>= 9) nTDC = (3*(13-nStrip)+((iPadX/4)%3));
2156       else if (nStrip< 9 && nStrip>= 4) nTDC = (3*( 8-nStrip)+((iPadX/4)%3));
2157       else if (nStrip< 4) nTDC = (3*( 3-nStrip)+((iPadX/4)%3));
2158     }
2159     else if (nPlate==3) {
2160       if (nStrip==18) nTDC = (3*(22-nStrip)+((iPadX/4)%3));
2161       else if (nStrip<18 && nStrip>=13) nTDC = (3*(17-nStrip)+((iPadX/4)%3));
2162       else if (nStrip<13 && nStrip>= 8) nTDC = (3*(12-nStrip)+((iPadX/4)%3));
2163       else if (nStrip< 8 && nStrip>= 3) nTDC = (3*( 7-nStrip)+((iPadX/4)%3));
2164       else if (nStrip< 3) nTDC = (3*( 2-nStrip)+((iPadX/4)%3));
2165     }
2166     else if (nPlate==2) {
2167       if (nStrip>=13) nTDC = (3*(17-nStrip)+((iPadX/4)%3));
2168       else if (nStrip<13 && nStrip>= 8) nTDC = (3*(12-nStrip)+((iPadX/4)%3));
2169     }
2170
2171     break;
2172   case 3:
2173
2174     if (nPlate==4) {
2175       if (nStrip==18) nTDC = (3*(nStrip-18)+2-(iPadX/4)%3);
2176       else if (nStrip<18 && nStrip>=13) nTDC = (3*(nStrip-13)+2-(iPadX/4)%3);
2177       else if (nStrip<13 && nStrip>= 8) nTDC = (3*(nStrip- 8)+2-(iPadX/4)%3);
2178       else if (nStrip< 8 && nStrip>= 3) nTDC = (3*(nStrip- 3)+2-(iPadX/4)%3);
2179       else if (nStrip< 3) nTDC = (3*(nStrip+ 2)+2-(iPadX/4)%3);
2180     }
2181     else if (nPlate==3) {
2182       if (nStrip>=17) nTDC = (3*(nStrip-17)+2-(iPadX/4)%3);
2183       else if (nStrip<17 && nStrip>=12) nTDC = (3*(nStrip-12)+2-(iPadX/4)%3);
2184       else if (nStrip<12 && nStrip>= 7) nTDC = (3*(nStrip- 7)+2-(iPadX/4)%3);
2185       else if (nStrip< 7 && nStrip>= 2) nTDC = (3*(nStrip- 2)+2-(iPadX/4)%3);
2186       else if (nStrip< 2) nTDC = (3*(nStrip+ 3)+2-(iPadX/4)%3);
2187     }
2188     else if (nPlate==2) {
2189       if (nStrip>=12) nTDC = (3*(nStrip-12)+2-(iPadX/4)%3);
2190       else if (nStrip <12 && nStrip>= 7) nTDC = (3*(nStrip- 7)+2-(iPadX/4)%3);
2191     }
2192
2193     break;
2194
2195   }
2196
2197   return nTDC;
2198
2199 }
2200
2201 //---------------------------------------------------------------------------
2202 Int_t AliTOFRawStream::Geant2Chain(Int_t vol[])
2203 {
2204   //
2205   // To convert:
2206   //      nSector number -vol[0]- (variable in [0,17])
2207   //      nPlate  number -vol[1]- (variable in [0, 5])
2208   //      nStrip  number -vol[2]- (variable in [0,14/18])
2209   //      nPadZ   number -vol[3]- (variable in [0, 1])
2210   //      nPadX   number -vol[4]- variable in [0,47])
2211   // in:
2212   //      nChain (variable in [0; 1]) -> number of the TRM chain
2213   //
2214
2215   Int_t nChain = -1;
2216
2217   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
2218     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
2219     return nChain;
2220   }
2221   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
2222     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
2223     return nChain;
2224   }
2225   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
2226     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
2227     return nChain;
2228   }
2229   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ())
2230     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
2231   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX())
2232     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
2233   if ( vol[3]>=AliTOFGeometry::NpadZ() ) {
2234     printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
2235     return nChain;
2236   }
2237
2238   Int_t iPadX = vol[4];
2239
2240   if (iPadX<12 || iPadX>=36) nChain = 0;
2241   else nChain = 1;
2242
2243   return nChain;
2244
2245 }
2246
2247 //---------------------------------------------------------------------------
2248 Int_t AliTOFRawStream::Geant2Channel(Int_t vol[])
2249 {
2250   //
2251   // To convert:
2252   //      nSector number -vol[0]- (variable in [0,17])
2253   //      nPlate  number -vol[1]- (variable in [0, 5])
2254   //      nStrip  number -vol[2]- (variable in [0,14/18])
2255   //      nPadZ   number -vol[3]- (variable in [0, 1])
2256   //      nPadX   number -vol[4]- (variable in [0,47])
2257   // in:
2258   //      nChannel (variable in [0; 7]) -> number of the TDC channel
2259   //
2260
2261   Int_t nChannel = -1;
2262
2263   if (vol[0]<0 || vol[0]>=AliTOFGeometry::NSectors()) {
2264     printf(" AliTOFRawStream - Error: the sector number (%i) is out of the range: [0,17]\n", vol[0]);
2265     return nChannel;
2266   }
2267   if (vol[1]<0 || vol[1]>=AliTOFGeometry::NPlates()) {
2268     printf(" AliTOFRawStream - Error: the module number (%i) is out of the range: [0,4]\n", vol[1]);
2269     return nChannel;
2270   }
2271   if (vol[2]<0 || vol[2]>=AliTOFGeometry::NStrip(vol[1])) {
2272     printf(" AliTOFRawStream - Error: the strip number (%i) is out of the range: [0,%i]\n", vol[2], AliTOFGeometry::NStrip(vol[1]));
2273     return nChannel;
2274   }
2275   if (vol[3]<0 || vol[3]>=AliTOFGeometry::NpadZ())
2276     printf(" AliTOFRawStream - Error: the padz number (%i) is out of the range: [0,1]\n", vol[3]);
2277   if (vol[4]<0 || vol[4]>=AliTOFGeometry::NpadX())
2278     printf(" AliTOFRawStream - Error: the padx number (%i) is out of the range: [0,47]\n", vol[4]);
2279   if ( vol[3]>=AliTOFGeometry::NpadZ() ) {
2280     printf("Maybe you have to invert the order between vol[3](=%i) and vol[4](=%i)\n", vol[3], vol[4]);
2281     return nChannel;
2282   }
2283
2284   Int_t iPadZ   = vol[3];
2285   Int_t iPadX   = vol[4];
2286
2287   Int_t iDDL = Geant2DDL(vol)%4;
2288
2289   switch (iDDL) {
2290
2291   case 0:
2292     nChannel = ((2*(23-iPadX) + (1-iPadZ)))%8;
2293     break;
2294   case 1:
2295     nChannel = ((2*(iPadX-24) + (iPadZ)))%8;
2296     break;
2297   case 2:
2298     nChannel = ((2*(iPadX-24) + (iPadZ)))%8;
2299     break;
2300   case 3:
2301     nChannel = ((2*(23-iPadX) + (1-iPadZ)))%8;
2302     break;
2303   }
2304
2305   return nChannel;
2306
2307 }
2308
2309 //____________________________________________________________________________
2310 void AliTOFRawStream::Raw2Digits(AliRawReader* rawReader, TClonesArray * const digitsArray)
2311 {
2312   //
2313   // Converts raw data to digits for TOF
2314   //
2315
2316   TStopwatch stopwatch;
2317   stopwatch.Start();
2318
2319   //TClonesArray *fDigits = new TClonesArray("AliTOFdigit", 4000);
2320   //digitsTree->Branch("TOF", &fDigits);
2321   TClonesArray &aDigits = *digitsArray;
2322
2323   Int_t inholes = 0;
2324
2325   Clear();
2326   SetRawReader(rawReader);
2327
2328   //ofstream ftxt;
2329   //if (fVerbose==2) ftxt.open("TOFdigitsRead.txt",ios::app);
2330
2331   TClonesArray staticRawData("AliTOFrawData",10000);
2332   staticRawData.Clear();
2333   TClonesArray * clonesRawData = &staticRawData;
2334
2335   Int_t dummy = -1;
2336   Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
2337   Int_t digit[4];
2338
2339   const Int_t kMaxNumberOfTracksPerDigit = 3;
2340   Int_t tracks[kMaxNumberOfTracksPerDigit];
2341   for (Int_t ii=0; ii<kMaxNumberOfTracksPerDigit; ii++)
2342     tracks[ii] = -1;
2343   Int_t last = -1;
2344
2345   Int_t indexDDL = 0;
2346   Int_t iRawData = 0;
2347   AliTOFrawData *tofRawDatum = 0;
2348   for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
2349
2350     rawReader->Reset();
2351     if (fNewDecoderVersion) {
2352       AliInfo("Using New Decoder \n");
2353       LoadRawDataBuffers(indexDDL, 0);
2354     }
2355     else
2356       LoadRawData(indexDDL);
2357
2358     clonesRawData = GetRawData();
2359     if (clonesRawData->GetEntriesFast()!=0) AliInfo(Form(" TOF raw data number = %3d", clonesRawData->GetEntriesFast()));
2360     for (iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
2361
2362       tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
2363
2364       //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
2365       if (tofRawDatum->GetTOF()==-1) continue;
2366
2367       EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
2368                            tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
2369
2370       dummy = detectorIndex[3];
2371       detectorIndex[3] = detectorIndex[4];//padz
2372       detectorIndex[4] = dummy;//padx
2373
2374       digit[0] = tofRawDatum->GetTOF();
2375       digit[1] = tofRawDatum->GetTOT();
2376       digit[2] = tofRawDatum->GetTOT();
2377       digit[3] = -1;//tofRawDatum->GetTOF(); //tofND
2378
2379       dummy = detectorIndex[3];
2380       detectorIndex[3] = detectorIndex[4];//padx
2381       detectorIndex[4] = dummy;//padz
2382
2383       // Do not reconstruct anything in the holes
2384       if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
2385         if (detectorIndex[1]==2) { // plate with holes
2386           inholes++;
2387           continue;
2388         }
2389       }
2390
2391       last = digitsArray->GetEntriesFast();
2392       new (aDigits[last]) AliTOFdigit(tracks, detectorIndex, digit);
2393       /*
2394       if (fVerbose==2) {
2395         if (indexDDL<10) ftxt << "  " << indexDDL;
2396         else         ftxt << " " << indexDDL;
2397         if (tofRawDatum->GetTRM()<10) ftxt << "  " << tofRawDatum->GetTRM();
2398         else         ftxt << " " << tofRawDatum->GetTRM();
2399         ftxt << "  " << tofRawDatum->GetTRMchain();
2400         if (tofRawDatum->GetTDC()<10) ftxt << "  " << tofRawDatum->GetTDC();
2401         else         ftxt << " " << tofRawDatum->GetTDC();
2402         ftxt << "  " << tofRawDatum->GetTDCchannel();
2403
2404         if (detectorIndex[0]<10) ftxt  << "  ->  " << detectorIndex[0];
2405         else              ftxt  << "  -> " << detectorIndex[0];
2406         ftxt << "  " << detectorIndex[1];
2407         if (detectorIndex[2]<10) ftxt << "  " << detectorIndex[2];
2408         else              ftxt << " " << detectorIndex[2];
2409         ftxt << "  " << detectorIndex[4];
2410         if (detectorIndex[4]<10) ftxt << "  " << detectorIndex[3];
2411         else              ftxt << " " << detectorIndex[3];
2412
2413         if (digit[1]<10)ftxt << "        " << digit[1];
2414         else if (digit[1]>=10 && digit[1]<100) ftxt << "      " << digit[1];
2415         else ftxt << "      " << digit[1];
2416         if (digit[0]<10) ftxt << "      " << digit[0] << endl;
2417         else if (digit[0]>=10 && digit[0]<100)   ftxt << "    " << digit[0] << endl;
2418         else if (digit[0]>=100 && digit[0]<1000) ftxt << "    " << digit[0] << endl;
2419         else ftxt << "   " << digit[3] << endl;
2420       }
2421       */
2422       AliDebug(2, Form(" Raw data reading %2d -> %2d %1d %2d %1d %2d (%d, %d, %d)",
2423                        last,
2424                        detectorIndex[0], detectorIndex[1], detectorIndex[2], detectorIndex[4], detectorIndex[3],
2425                        digit[0], digit[1], digit[3]));
2426
2427       tofRawDatum = 0;
2428     } // loop on tofRawData array
2429
2430     clonesRawData->Clear();
2431
2432   } // DDL Loop
2433
2434   //if (fVerbose==2) ftxt.close();
2435
2436
2437   if (inholes) AliWarning(Form("Raw data in the TOF holes: %d",inholes));
2438
2439   Int_t nDigits = digitsArray->GetEntries();
2440   AliDebug(1, Form("Got %d TOF digits", nDigits));
2441   AliDebug(1, Form("Execution time to read TOF raw data and fill TOF digit tree : R:%.2fs C:%.2fs",
2442                    stopwatch.RealTime(),stopwatch.CpuTime()));
2443
2444 }
2445
2446 //____________________________________________________________________________
2447 void AliTOFRawStream::Raw2SDigits(AliRawReader* rawReader, TClonesArray * const sdigitsArray)
2448 {
2449   //
2450   // Converts raw data to sdigits for TOF
2451   //
2452
2453   TStopwatch stopwatch;
2454   stopwatch.Start();
2455
2456   Int_t inholes = 0;
2457
2458   //if(!GetLoader()->TreeS()) {MakeTree("S");  MakeBranch("S");}
2459   TClonesArray &aSDigits = *sdigitsArray;
2460
2461   Clear();
2462   SetRawReader(rawReader);
2463
2464   //ofstream ftxt;
2465   //if (fVerbose==2) ftxt.open("TOFsdigitsRead.txt",ios::app);
2466
2467   TClonesArray staticRawData("AliTOFrawData",10000);
2468   staticRawData.Clear();
2469   TClonesArray * clonesRawData = &staticRawData;
2470
2471   Int_t dummy = -1;
2472   Int_t detectorIndex[5] = {-1, -1, -1, -1, -1};
2473   Int_t digit[2];
2474   Int_t track = -1;
2475   Int_t last = -1;
2476
2477   Int_t indexDDL = 0;
2478   Int_t iRawData = 0;
2479   AliTOFrawData *tofRawDatum = 0;
2480   for (indexDDL=0; indexDDL<AliDAQ::NumberOfDdls("TOF"); indexDDL++) {
2481
2482     rawReader->Reset();
2483     if (fNewDecoderVersion) {
2484       AliInfo("Using New Decoder \n");
2485       LoadRawDataBuffers(indexDDL, 0);
2486     }
2487     else
2488       LoadRawData(indexDDL);
2489
2490     clonesRawData = GetRawData();
2491     if (clonesRawData->GetEntriesFast()!=0) AliInfo(Form(" TOF raw data number = %3d", clonesRawData->GetEntriesFast()));
2492     for (iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
2493
2494       tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);
2495
2496       //if (tofRawDatum->GetTOT()==-1 || tofRawDatum->GetTOF()==-1) continue;
2497       if (tofRawDatum->GetTOF()==-1) continue;
2498
2499       EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
2500                            tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
2501
2502       dummy = detectorIndex[3];
2503       detectorIndex[3] = detectorIndex[4];//padz
2504       detectorIndex[4] = dummy;//padx
2505
2506       digit[0] = tofRawDatum->GetTOF();
2507       digit[1] = tofRawDatum->GetTOT();
2508
2509       dummy = detectorIndex[3];
2510       detectorIndex[3] = detectorIndex[4];//padx
2511       detectorIndex[4] = dummy;//padz
2512
2513       // Do not reconstruct anything in the holes
2514       if (detectorIndex[0]==13 || detectorIndex[0]==14 || detectorIndex[0]==15 ) { // sectors with holes
2515         if (detectorIndex[1]==2) { // plate with holes
2516           inholes++;
2517           continue;
2518         }
2519       }
2520
2521       last = sdigitsArray->GetEntriesFast();
2522       new (aSDigits[last]) AliTOFSDigit(track, detectorIndex, digit);
2523       /*
2524       if (fVerbose==2) {
2525         if (indexDDL<10) ftxt << "  " << indexDDL;
2526         else         ftxt << " " << indexDDL;
2527         if (tofRawDatum->GetTRM()<10) ftxt << "  " << tofRawDatum->GetTRM();
2528         else         ftxt << " " << tofRawDatum->GetTRM();
2529         ftxt << "  " << tofRawDatum->GetTRMchain();
2530         if (tofRawDatum->GetTDC()<10) ftxt << "  " << tofRawDatum->GetTDC();
2531         else         ftxt << " " << tofRawDatum->GetTDC();
2532         ftxt << "  " << tofRawDatum->GetTDCchannel();
2533
2534         if (detectorIndex[0]<10) ftxt  << "  ->  " << detectorIndex[0];
2535         else              ftxt  << "  -> " << detectorIndex[0];
2536         ftxt << "  " << detectorIndex[1];
2537         if (detectorIndex[2]<10) ftxt << "  " << detectorIndex[2];
2538         else              ftxt << " " << detectorIndex[2];
2539         ftxt << "  " << detectorIndex[4];
2540         if (detectorIndex[4]<10) ftxt << "  " << detectorIndex[3];
2541         else              ftxt << " " << detectorIndex[3];
2542
2543         if (digit[1]<10)ftxt << "        " << digit[1];
2544         else if (digit[1]>=10 && digit[1]<100) ftxt << "      " << digit[1];
2545         else ftxt << "      " << digit[1];
2546         if (digit[0]<10) ftxt << "      " << digit[0] << endl;
2547         else if (digit[0]>=10 && digit[0]<100)   ftxt << "    " << digit[0] << endl;
2548         else if (digit[0]>=100 && digit[0]<1000) ftxt << "    " << digit[0] << endl;
2549         else ftxt << "   " << digit[3] << endl;
2550       }
2551       */
2552       AliDebug(2, Form(" Raw data reading %2d -> %2d %1d %2d %1d %2d (%d, %d)",
2553                        last,
2554                        detectorIndex[0], detectorIndex[1], detectorIndex[2], detectorIndex[4], detectorIndex[3],
2555                        digit[0], digit[1]));
2556
2557       tofRawDatum = 0;
2558     } // while loop
2559
2560     clonesRawData->Clear();
2561
2562   } // DDL Loop
2563
2564   //if (fVerbose==2) ftxt.close();
2565
2566   if (inholes) AliWarning(Form("Clusters in the TOF holes: %d",inholes));
2567
2568   Int_t nSDigits = sdigitsArray->GetEntries();
2569   AliDebug(1, Form("Got %d TOF sdigits", nSDigits));
2570   AliDebug(1, Form("Execution time to read TOF raw data and fill TOF sdigit tree : R:%.2fs C:%.2fs",
2571                    stopwatch.RealTime(),stopwatch.CpuTime()));
2572
2573 }
2574
2575 void AliTOFRawStream::VolumeID2LTM(Int_t detind[],
2576                                    Int_t &iDDL,
2577                                    Int_t &iTRM,
2578                                    Int_t &iChain,
2579                                    Int_t &iTDC,
2580                                    Int_t &iChannel) const {
2581   //
2582   // To convert the TOF trigger macropad ID (i.e. detind)
2583   // into TOF OR signals equipment ID (i.e. iDDL, iTRM, iChain, iTDC, iChannel)
2584   //
2585
2586   const Int_t kFirstTDCnumber = 12;
2587
2588   iDDL=-1, iTRM = 3 , iChain=-1, iTDC=-1, iChannel=-1;
2589   if (detind[1]==0 || detind[1]==1 || (detind[1]==2 && detind[2]<=7)) {
2590     if (detind[4]<24)
2591       iDDL = detind[0]*4;
2592     else
2593       iDDL = detind[0]*4;
2594   }
2595   else {
2596     if (detind[4]<24)
2597       iDDL = detind[0]*4+2;
2598     else
2599       iDDL = detind[0]*4+2;
2600   }
2601
2602   iChain=fgkChainMap24[detind[1]][detind[2]];
2603   iTDC=(Int_t)(fgkChannelMap24[detind[1]][detind[2]]/8)+kFirstTDCnumber;
2604   iChannel=fgkChannelMap24[detind[1]][detind[2]]%8;
2605
2606 }
2607
2608 void AliTOFRawStream::LTM2VolumeID(Int_t iDDL,
2609                                    Int_t iTRM,
2610                                    Int_t iChain,
2611                                    Int_t iTDC,
2612                                    Int_t iChannel,
2613                                    Int_t detind0[], Int_t detind1[]) const {
2614   //
2615   // To convert the TOF OR signals equipment ID (i.e. iDDL, iTRM, iChain, iTDC, iChannel)
2616   // into TOF trigger macropad IDs (i.e. detind0 and detind1).
2617   // In general, a couple of neighbouring TOF semi-strip represents a TOF trigger macropad.
2618   //
2619
2620   const Int_t kFirstTDCnumber = 12;
2621
2622   Int_t iSector0=-1, iModule0=-1, iStrip0=-1, iPadX0=-1; // Le variabili del Volume ID
2623   Int_t iSector1=-1, iModule1=-1, iStrip1=-1, iPadX1=-1; // Le variabili del Volume ID
2624
2625   if( iDDL%2==1 && iTRM==3 && iTDC-kFirstTDCnumber>=0 && iTDC-kFirstTDCnumber<3 ) {
2626     iSector0 = (Int_t)(iDDL/4);
2627     iSector1 = (Int_t)(iDDL/4);
2628     Int_t iChan= iChannel+(iTDC-kFirstTDCnumber)*8;
2629     if( iDDL%4 == 1 ){
2630       if(iChain==0){      //CRATE 0
2631         iPadX0=0;
2632         iPadX1=0;
2633         iStrip0=fgkStrip0MapCrate0[iChan];
2634         iStrip1=fgkStrip1MapCrate0[iChan];
2635         iModule0=fgkModule0MapCrate0[iChan];
2636         iModule1=fgkModule1MapCrate0[iChan];
2637       }
2638       if(iChain==1){// CRATE 1
2639         iPadX0=24;
2640         iPadX1=24;
2641         iStrip0=fgkStrip0MapCrate1[iChan];
2642         iStrip1=fgkStrip1MapCrate1[iChan];
2643         iModule0=fgkModule0MapCrate1[iChan];
2644         iModule1=fgkModule1MapCrate1[iChan];
2645       }
2646
2647     }
2648     if( iDDL%4 == 3 ){
2649       if(iChain==1){// CRATE 3
2650         iPadX0=0;
2651         iPadX1=0;
2652         iStrip0=fgkStrip0MapCrate3[iChan];
2653         iStrip1=fgkStrip1MapCrate3[iChan];
2654         iModule0=fgkModule0MapCrate3[iChan];
2655         iModule1=fgkModule1MapCrate3[iChan];
2656       }
2657       if(iChain==0){// CRATE 2
2658         iPadX0=24;
2659         iPadX1=24;
2660         iStrip0=fgkStrip0MapCrate2[iChan];
2661         iStrip1=fgkStrip1MapCrate2[iChan];
2662         iModule0=fgkModule0MapCrate2[iChan];
2663         iModule1=fgkModule1MapCrate2[iChan];
2664       }
2665     }
2666   }
2667
2668   if(iStrip1==-1 || iModule1==-1){
2669     detind1[0]=-1;
2670     detind1[1]=-1;
2671     detind1[2]=-1;
2672     detind1[3]=-1;
2673     detind1[4]=-1;
2674   }
2675   else{
2676     detind1[0]=iSector1;
2677     detind1[1]=iModule1;
2678     detind1[2]=iStrip1;
2679     detind1[3]=iPadX1;
2680     detind1[4]=0;
2681   }
2682
2683   if(iStrip0==-1 || iModule0==-1){
2684     detind0[0]=-1;
2685     detind0[1]=-1;
2686     detind0[2]=-1;
2687     detind0[3]=-1;
2688     detind0[4]=-1;
2689   }
2690   else{
2691     detind0[0]=iSector0;
2692     detind0[1]=iModule0;
2693     detind0[2]=iStrip0;
2694     detind0[3]=iPadX0;
2695     detind0[4]=0;
2696   }
2697 }