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