TOF/AliTOFDDLRawData.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17 $Log$
  18 Revision 1.19  2007/06/22 11:37:47  cvetan
  19 Fixes in order to write correct raw-data on big-endian platforms (Marco)
  20
  21 Revision 1.18  2007/05/21 13:26:19  decaro
  22 Correction on matching_window control and bug fixing (R.Preghenella)
  23
  24 Revision 1.17  2007/05/10 09:29:34  hristov
  25 Last moment fixes and changes from v4-05-Release (Silvia)
  26
  27 Revision 1.16  2007/05/03 09:07:22  decaro
  28 Double digit in the same TDC channel. Wrong sequence during the raw data writing in unpacked mode: solved
  29
  30 Revision 1.15  2007/04/23 16:51:39  decaro
  31 Digits-to-raw_data conversion: correction for a more real description (A.De Caro, R.Preghenella)
  32
  33 Revision 1.14  2007/03/28 10:50:33  decaro
  34 Rounding off problem in rawData coding/decoding: solved
  35
  36 Revision 1.13  2007/02/20 15:57:00  decaro
  37 Raw data update: to read the TOF raw data defined in UNPACKED mode
  38
  39 Revision 1.12  2006/08/22 13:29:42  arcelli
  40 removal of effective c++ warnings (C.Zampolli)
  41
  42 Revision 1.11  2006/08/10 14:46:54  decaro
  43 TOF raw data format: updated version
  44
  45 Revision 1.10.1  2006/06/28 A.De Caro
  46         Update TOF raw data format
  47                according to the final version
  48                (see ALICE internal note in preparation
  49                 'ALICE TOF raw data format')
  50
  51 Revision 0.02  2005/7/25 A.De Caro
  52         Update number of bits allocated for time-of-flight
  53                and 'charge' measurements
  54
  55 Revision 0.01  2004/6/11 A.De Caro, S.B.Sellitto, R.Silvestri
  56         First implementation: global methods RawDataTOF
  57                                              GetDigits
  58 */
  59
  60 ////////////////////////////////////////////////////////////////////
  61 //                                                                //
  62 // This class contains the methods to create the Raw Data files   //
  63 // for the TOF detector starting from the Digits.                 //
  64 // In this implementation, we defined the structure               //
  65 // of the ALICE-TOF raw data (according to the                    //
  66 // ALICE technical note, in preparation)                          //
  67 // starting from the TOF digit format.                            //
  68 //                                                                //
  69 ////////////////////////////////////////////////////////////////////
  70
  71 #include "Riostream.h"
  72
  73 #include "TBranch.h"
  74 #include "TClonesArray.h"
  75 #include "TMath.h"
  76 #include "TRandom.h"
  77
  78 #include "AliBitPacking.h"
  79 #include "AliDAQ.h"
  80 #include "AliLog.h"
  81 //#include "AliRawDataHeader.h"
  82 #include "AliRawDataHeaderSim.h"
  83 #include "AliFstream.h"
  84
  85 #include "AliTOFDDLRawData.h"
  86 #include "AliTOFDigitMap.h"
  87 #include "AliTOFdigit.h"
  88 #include "AliTOFGeometry.h"
  89 #include "AliTOFRawStream.h"
  90 //#include "AliTOFCableLengthMap.h"
  91
  92 extern TRandom *gRandom;
  93
  94 ClassImp(AliTOFDDLRawData)
  95
  96 //---------------------------------------------------------------------------
  97 AliTOFDDLRawData::AliTOFDDLRawData():
  98   TObject(),
  99   fVerbose(0),
 100   fIndex(-1),
 101   fPackedAcquisition(kFALSE),
 102   fFakeOrphaneProduction(kFALSE),
 103   fMatchingWindow(8192),
 104   fTOFdigitMap(new AliTOFDigitMap()),
 105   fTOFdigitArray(0x0)
 106   //fTOFrawStream(AliTOFRawStream()),
 107   //fTOFCableLengthMap(new AliTOFCableLengthMap())
 108 {
 109   //Default constructor
 110 }
 111 //----------------------------------------------------------------------------
 112 AliTOFDDLRawData::AliTOFDDLRawData(const AliTOFDDLRawData &source) :
 113   TObject(source),
 114   fVerbose(source.fVerbose),
 115   fIndex(source.fIndex),
 116   fPackedAcquisition(source.fPackedAcquisition),
 117   fFakeOrphaneProduction(source.fFakeOrphaneProduction),
 118   fMatchingWindow(source.fMatchingWindow),
 119   fTOFdigitMap(source.fTOFdigitMap),
 120   fTOFdigitArray(source.fTOFdigitArray)
 121   //fTOFrawStream(source.fTOFrawStream),
 122   //fTOFCableLengthMap(source.fTOFCableLengthMap)
 123  {
 124   //Copy Constructor
 125   return;
 126 }
 127
 128 //----------------------------------------------------------------------------
 129 AliTOFDDLRawData& AliTOFDDLRawData::operator=(const AliTOFDDLRawData &source) {
 130   //Assigment operator
 131
 132   if (this == &source)
 133     return *this;
 134
 135   TObject::operator=(source);
 136   fIndex=source.fIndex;
 137   fVerbose=source.fVerbose;
 138   fPackedAcquisition=source.fPackedAcquisition;
 139   fFakeOrphaneProduction=source.fFakeOrphaneProduction;
 140   fMatchingWindow=source.fMatchingWindow;
 141   fTOFdigitMap=source.fTOFdigitMap;
 142   fTOFdigitArray=source.fTOFdigitArray;
 143   //fTOFrawStream=source.fTOFrawStream;
 144   //fTOFCableLengthMap=source.fTOFCableLengthMap;
 145   return *this;
 146 }
 147
 148 //----------------------------------------------------------------------------
 149 AliTOFDDLRawData::~AliTOFDDLRawData()
 150 {
 151   delete fTOFdigitMap;
 152   //delete fTOFrawStream;
 153   //delete fTOFCableLengthMap;
 154 }
 155 //----------------------------------------------------------------------------
 156 Int_t AliTOFDDLRawData::RawDataTOF(TBranch* branch)
 157 {
 158   //
 159   // This method creates the Raw data files for TOF detector
 160   //
 161
 162   const Int_t kSize = 5000; // max number of digits per DDL file times 2
 163
 164   UInt_t buf[kSize];
 165
 166   // To clear the digit indices map for each event
 167   fTOFdigitMap->Clear();
 168
 169   //fTOFrawStream->Clear();
 170
 171   fIndex = -1;
 172
 173   fTOFdigitArray = * (TClonesArray**) branch->GetAddress();
 174
 175   char fileName[15];
 176   AliFstream* outfile;      // logical name of the output file
 177
 178   //AliRawDataHeader header;
 179   AliRawDataHeaderSim header;
 180
 181   UInt_t sizeRawData = 0;
 182
 183   branch->GetEvent();
 184
 185   GetDigits();
 186
 187   //if (!fPackedAcquisition) fMatchingWindow = 2097152;//AdC
 188
 189   Int_t jj = -1;
 190   Int_t iDDL = -1;
 191   Int_t nDDL = -1;
 192   Int_t nTRM =  0;
 193   Int_t iChain = -1;
 194
 195   UInt_t nWordsPerTRM = 0;
 196
 197   //loop over TOF DDL files
 198   for (nDDL=0; nDDL<AliDAQ::NumberOfDdls("TOF"); nDDL++) {
 199
 200     strcpy(fileName,AliDAQ::DdlFileName("TOF",nDDL)); //The name of the output file
 201
 202     outfile = new AliFstream(fileName);
 203     //iDDL = fTOFrawStream->GetDDLnumberPerSector(nDDL);
 204     iDDL = AliTOFRawStream::GetDDLnumberPerSector(nDDL);
 205
 206     // write Dummy DATA HEADER
 207     UInt_t dataHeaderPosition = outfile->Tellp();
 208     outfile->WriteBuffer((char*)(&header),sizeof(header));
 209
 210     // DRM section: trailer
 211     MakeDRMtrailer(buf);
 212
 213     // LTM section
 214     fIndex++;
 215     buf[fIndex] = MakeFiller();
 216     MakeLTMtrailer(buf);
 217     MakeLTMdata(buf);
 218     MakeLTMheader(buf);
 219
 220     // loop on TRM number per DRM
 221     for (nTRM=AliTOFGeometry::NTRM(); nTRM>=3; nTRM--) {
 222
 223       nWordsPerTRM = 0;
 224
 225       // the slot number 3 of the even DRM (i.e. right) doesn't contain TDC digit data
 226       if (iDDL%2==0 && nTRM==3) continue;
 227
 228       // TRM global trailer
 229       MakeTRMtrailer(buf);
 230
 231       // loop on TRM chain number per TRM
 232       for (iChain=AliTOFGeometry::NChain()-1; iChain>=0; iChain--) {
 233
 234         // TRM chain trailer
 235         MakeTRMchainTrailer(iChain, buf);
 236         nWordsPerTRM++;
 237
 238         // TRM TDC digits
 239         MakeTDCdigits(nDDL, nTRM, iChain, buf, nWordsPerTRM);
 240
 241         // TRM chain header
 242         MakeTRMchainHeader(nTRM, iChain, buf);
 243         nWordsPerTRM++;
 244
 245       } // end loop on iChain
 246
 247       // TRM global header
 248       MakeTRMheader(nTRM, buf);
 249
 250       // TRM filler in case where TRM data number is odd
 251       if (nWordsPerTRM%2!=0) MakeTRMfiller(buf, nWordsPerTRM);
 252
 253     } // end loop on nTRM
 254
 255     // DRM section: in
 256     MakeDRMheader(nDDL, buf);
 257
 258     ReverseArray(buf, fIndex+1);
 259
 260     outfile->WriteBuffer((char *)buf,((fIndex+1)*sizeof(UInt_t)));
 261
 262     for (jj=0; jj<(fIndex+1); jj++) buf[jj]=0;
 263     fIndex = -1;
 264
 265     //Write REAL DATA HEADER
 266     UInt_t currentFilePosition = outfile->Tellp();
 267     sizeRawData = currentFilePosition - dataHeaderPosition - sizeof(header);
 268     header.fSize = currentFilePosition - dataHeaderPosition;
 269     header.SetAttribute(0);  // valid data
 270     outfile->Seekp(dataHeaderPosition);
 271     outfile->WriteBuffer((char*)(&header),sizeof(header));
 272     outfile->Seekp(currentFilePosition);
 273
 274     delete outfile;
 275
 276   } //end loop on DDL file number
 277
 278   return 0;
 279
 280 }
 281
 282 //----------------------------------------------------------------------------
 283 void AliTOFDDLRawData::GetDigits()
 284 {
 285   //
 286   // Fill the TOF volumes' map with the TOF digit indices
 287   //
 288
 289   Int_t vol[5] = {-1,-1,-1,-1,-1};
 290
 291   Int_t digit = -1;
 292   Int_t ndigits = fTOFdigitArray->GetEntries();
 293
 294   AliTOFdigit *digs;
 295
 296   // loop on TOF digits
 297   for (digit=0; digit<ndigits; digit++) {
 298     digs = (AliTOFdigit*)fTOFdigitArray->UncheckedAt(digit);
 299
 300     vol[0] = digs->GetSector(); // Sector Number (0-17)
 301     vol[1] = digs->GetPlate();  // Plate Number (0-4)
 302     vol[2] = digs->GetStrip();  // Strip Number (0-14/18)
 303     vol[3] = digs->GetPadx();   // Pad Number in x direction (0-47)
 304     vol[4] = digs->GetPadz();   // Pad Number in z direction (0-1)
 305
 306     fTOFdigitMap->AddDigit(vol, digit);
 307
 308   } // close loop on digit del TOF
 309
 310 }
 311
 312 //----------------------------------------------------------------------------
 313 void AliTOFDDLRawData::MakeDRMheader(Int_t nDDL, UInt_t *buf)
 314 {
 315   //
 316   // DRM global header
 317   //
 318
 319   //Int_t iDDL = fTOFrawStream->GetDDLnumberPerSector(nDDL);
 320   Int_t iDDL = AliTOFRawStream::GetDDLnumberPerSector(nDDL);
 321
 322   //Int_t iSector = fTOFrawStream->GetSectorNumber(nDDL);
 323   Int_t iSector = AliTOFRawStream::GetSectorNumber(nDDL);
 324
 325   UInt_t baseWord=0;
 326   UInt_t word;
 327
 328   // DRM event CRC
 329   baseWord=0;
 330   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
 331   AliBitPacking::PackWord(word,baseWord, 0, 3);
 332   word = 0; // event CRC
 333   AliBitPacking::PackWord(word,baseWord, 4,19);
 334   word = 0; // reserved for future use
 335   AliBitPacking::PackWord(word,baseWord,20,27);
 336   word = 4; // 0100 -> DRM header ID
 337   AliBitPacking::PackWord(word,baseWord,28,31);
 338   fIndex++;
 339   buf[fIndex]=baseWord;
 340
 341   // DRM status header 4
 342   baseWord=0;
 343   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
 344   AliBitPacking::PackWord(word,baseWord, 0, 3);
 345   word = 0; // temperature
 346   AliBitPacking::PackWord(word,baseWord, 4,13);
 347   word = 0; // zero
 348   AliBitPacking::PackWord(word,baseWord, 14,14);
 349   word = 0; // ACK
 350   AliBitPacking::PackWord(word,baseWord, 15,15);
 351   word = 0; // Sens AD
 352   AliBitPacking::PackWord(word,baseWord, 16,18);
 353   word = 0; // zero
 354   AliBitPacking::PackWord(word,baseWord, 19,19);
 355   word = 0; // reserved for future use
 356   AliBitPacking::PackWord(word,baseWord, 20,27);
 357   word = 4; // 0100 -> DRM header ID
 358   AliBitPacking::PackWord(word,baseWord,28,31);
 359   fIndex++;
 360   buf[fIndex]=baseWord;
 361
 362   // DRM status header 3
 363   baseWord=0;
 364   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
 365   AliBitPacking::PackWord(word,baseWord, 0, 3);
 366   word = 0; // L0 BCID
 367   AliBitPacking::PackWord(word,baseWord, 4,15);
 368   word = 0; // Run Time info
 369   AliBitPacking::PackWord(word,baseWord, 16,27);
 370   word = 4; // 0100 -> DRM header ID
 371   AliBitPacking::PackWord(word,baseWord,28,31);
 372   fIndex++;
 373   buf[fIndex]=baseWord;
 374
 375   // DRM status header 2
 376   baseWord=0;
 377   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
 378   AliBitPacking::PackWord(word,baseWord, 0, 3);
 379
 380   if (iDDL%2==1) {
 381     word = 2047; // enable ID: [00000000000;11111111111] for odd
 382                  // (i.e. right) crates
 383     AliBitPacking::PackWord(word,baseWord, 4,14);
 384   } else {
 385     word = 2045; // enable ID: [00000000000;11111111101] for even
 386                  // (i.e. left) crates
 387     AliBitPacking::PackWord(word,baseWord, 4,14);
 388   }
 389
 390   word = 0; //
 391   AliBitPacking::PackWord(word,baseWord,15,15);
 392   word = 0; // fault ID
 393   AliBitPacking::PackWord(word,baseWord,16,26);
 394   word = 0; // RTO
 395   AliBitPacking::PackWord(word,baseWord,27,27);
 396   word = 4; // 0100 -> DRM header ID
 397   AliBitPacking::PackWord(word,baseWord,28,31);
 398   fIndex++;
 399   buf[fIndex]=baseWord;
 400
 401   // DRM status header 1
 402   baseWord=0;
 403   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
 404   AliBitPacking::PackWord(word,baseWord, 0, 3);
 405
 406   if (iDDL%2==1) {
 407     word = 2047; // slot ID: [00000000000;11111111111] for odd
 408                  // (i.e. right) crates
 409     AliBitPacking::PackWord(word,baseWord, 4,14);
 410   } else {
 411     word = 2045; // slot ID: [00000000000;11111111101] for even
 412                  // (i.e. left) crates
 413     AliBitPacking::PackWord(word,baseWord, 4,14);
 414   }
 415
 416   word = 1; // LHC clock status: 1/0
 417   AliBitPacking::PackWord(word,baseWord,15,15);
 418   word = 0; // Vers ID
 419   AliBitPacking::PackWord(word,baseWord,16,20);
 420   word = 0; // DRMH size
 421   AliBitPacking::PackWord(word,baseWord,21,24);
 422   word = 0; // reserved for future use
 423   AliBitPacking::PackWord(word,baseWord,25,27);
 424   word = 4; // 0100 -> DRM header ID
 425   AliBitPacking::PackWord(word,baseWord,28,31);
 426   fIndex++;
 427   buf[fIndex]=baseWord;
 428
 429   // DRM global header
 430   baseWord=0;
 431   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
 432   AliBitPacking::PackWord(word,baseWord, 0, 3);
 433   word = fIndex+1 + 1; // event words
 434   AliBitPacking::PackWord(word,baseWord, 4,20);
 435   word = iDDL; // crate ID [0;3]
 436   AliBitPacking::PackWord(word,baseWord,21,22);
 437   word = iSector; // sector ID [0;17]
 438   AliBitPacking::PackWord(word,baseWord,23,27);
 439   word = 4; // 0100 -> DRM header ID
 440   AliBitPacking::PackWord(word,baseWord,28,31);
 441   fIndex++;
 442   buf[fIndex]=baseWord;
 443
 444 }
 445
 446 //----------------------------------------------------------------------------
 447 void AliTOFDDLRawData::MakeDRMtrailer(UInt_t *buf)
 448 {
 449   //
 450   // DRM global trailer
 451   //
 452
 453   UInt_t baseWord;
 454   UInt_t word;
 455
 456   baseWord=0;
 457   word = 1; // 0001 -> DRM data are coming from the VME slot number 1
 458   AliBitPacking::PackWord(word,baseWord, 0, 3);
 459   word = 0; // local event counter
 460   AliBitPacking::PackWord(word,baseWord, 4,15);
 461   word = 0; // reserved for future use
 462   AliBitPacking::PackWord(word,baseWord,16,27);
 463   word = 5; // 0101 -> DRM trailer ID
 464   AliBitPacking::PackWord(word,baseWord,28,31);
 465   fIndex++;
 466   buf[fIndex]=baseWord;
 467
 468 }
 469
 470 //----------------------------------------------------------------------------
 471 void AliTOFDDLRawData::MakeLTMheader(UInt_t *buf)
 472 {
 473   //
 474   // LTM header
 475   //
 476
 477   UInt_t baseWord;
 478   UInt_t word;
 479
 480   baseWord=0;
 481   word = 2; // 0010 -> LTM data are coming from the VME slot number 2
 482   AliBitPacking::PackWord(word,baseWord, 0, 3);
 483   word = 35; // event words
 484   AliBitPacking::PackWord(word,baseWord, 4,16);
 485   word = 0; // crc error
 486   AliBitPacking::PackWord(word,baseWord,17,17);
 487   word = 0; // fault
 488   AliBitPacking::PackWord(word,baseWord,18,23);
 489   word = 0;
 490   AliBitPacking::PackWord(word,baseWord,24,27);
 491   word = 4; // 0100 -> LTM header ID
 492   AliBitPacking::PackWord(word,baseWord,28,31);
 493   fIndex++;
 494   buf[fIndex]=baseWord;
 495
 496 }
 497
 498 //----------------------------------------------------------------------------
 499 void AliTOFDDLRawData::MakeLTMdata(UInt_t *buf)
 500 {
 501   //
 502   // LTM data
 503   //
 504
 505   UInt_t baseWord;
 506   UInt_t word;
 507
 508   baseWord=0;
 509   word = 100; // Local temperature in LTM5 -> 4 X 25 degree (environment temperature)
 510   AliBitPacking::PackWord(word,baseWord, 0, 9);
 511   word = 100; // Local temperature in LTM6 -> 4 X 25 degree (environment temperature)
 512   AliBitPacking::PackWord(word,baseWord,10,19);
 513   word = 100; // Local temperature in LTM7 -> 4 X 25 degree (environment temperature)
 514   AliBitPacking::PackWord(word,baseWord,20,29);
 515   word = 0;
 516   AliBitPacking::PackWord(word,baseWord,30,31);
 517
 518   fIndex++;
 519   buf[fIndex]=baseWord;
 520
 521   // Local temperature in LTM2, LMT3, LTM4 -> 4 X 25 degree (environment temperature)
 522   fIndex++;
 523   buf[fIndex]=baseWord;
 524
 525   // Local temperature in FEAC7, FEAC8, LTM1 -> 4 X 25 degree (environment temperature)
 526   fIndex++;
 527   buf[fIndex]=baseWord;
 528
 529   // Local temperature in FEAC4, FEAC5, FEAC6 -> 4 X 25 degree (environment temperature)
 530   fIndex++;
 531   buf[fIndex]=baseWord;
 532
 533   // Local temperature in FEAC1, FEAC2, FEAC3 -> 4 X 25 degree (environment temperature)
 534   fIndex++;
 535   buf[fIndex]=baseWord;
 536
 537   baseWord=0;
 538   word = 0; // GND-FEAC15 -> Voltage drop between GND and FEAC15
 539   AliBitPacking::PackWord(word,baseWord, 0, 9);
 540   word = 0; // VTH16 -> Thereshould voltage for FEAC16
 541   AliBitPacking::PackWord(word,baseWord,10,19);
 542   word = 0; // GND-FEAC16 -> Voltage drop between GND and FEAC16
 543   AliBitPacking::PackWord(word,baseWord,20,29);
 544   word = 0;
 545   AliBitPacking::PackWord(word,baseWord,30,31);
 546
 547   fIndex++;
 548   buf[fIndex]=baseWord;
 549
 550   // VTH14 -> Thereshould voltage for FEAC14
 551   // GND-FEAC14 -> Voltage drop between GND and FEAC14
 552   // VTH15 -> Thereshould voltage for FEAC15
 553   fIndex++;
 554   buf[fIndex]=baseWord;
 555
 556   // GND-FEAC12 -> Voltage drop between GND and FEAC12
 557   // VTH13 -> Thereshould voltage for FEAC13
 558   // GND-FEAC13 -> Voltage drop between GND and FEAC13
 559   fIndex++;
 560   buf[fIndex]=baseWord;
 561
 562   // VTH11 -> Thereshould voltage for FEAC11
 563   // GND-FEAC11 -> Voltage drop between GND and FEAC11
 564   // VTH12 -> Thereshould voltage for FEAC12
 565   fIndex++;
 566   buf[fIndex]=baseWord;
 567
 568   // GND-FEAC9 -> Voltage drop between GND and FEAC9
 569   // VTH10 -> Thereshould voltage for FEAC10
 570   // GND-FEAC10 -> Voltage drop between GND and FEAC10
 571   fIndex++;
 572   buf[fIndex]=baseWord;
 573
 574   // VTH8 -> Thereshould voltage for FEAC8
 575   // GND-FEAC8 -> Voltage drop between GND and FEAC8
 576   // VTH9 -> Thereshould voltage for FEAC9
 577   fIndex++;
 578   buf[fIndex]=baseWord;
 579
 580   // GND-FEAC6 -> Voltage drop between GND and FEAC6
 581   // VTH7 -> Thereshould voltage for FEAC7
 582   // GND-FEAC7 -> Voltage drop between GND and FEAC7
 583   fIndex++;
 584   buf[fIndex]=baseWord;
 585
 586   // VTH5 -> Thereshould voltage for FEAC5
 587   // GND-FEAC5 -> Voltage drop between GND and FEAC5
 588   // VTH6 -> Thereshould voltage for FEAC6
 589   fIndex++;
 590   buf[fIndex]=baseWord;
 591
 592   // GND-FEAC3 -> Voltage drop between GND and FEAC3
 593   // VTH4 -> Thereshould voltage for FEAC4
 594   // GND-FEAC4 -> Voltage drop between GND and FEAC4
 595   fIndex++;
 596   buf[fIndex]=baseWord;
 597
 598   // VTH2 -> Thereshould voltage for FEAC2
 599   // GND-FEAC2 -> Voltage drop between GND and FEAC2
 600   // VTH3 -> Thereshould voltage for FEAC3
 601   fIndex++;
 602   buf[fIndex]=baseWord;
 603
 604   // LV16 -> Low Voltage measured by FEAC16
 605   // GND-FEAC1 -> Voltage drop between GND and FEAC1
 606   // VTH1 -> Thereshould voltage for FEAC1
 607   fIndex++;
 608   buf[fIndex]=baseWord;
 609
 610   // Low Voltage measured by FEAC13, FEAC14, FEAC15
 611   fIndex++;
 612   buf[fIndex]=baseWord;
 613
 614   // Low Voltage measured by FEAC10, FEAC11, FEAC12
 615   fIndex++;
 616   buf[fIndex]=baseWord;
 617
 618   // Low Voltage measured by FEAC7, FEAC8, FEAC9
 619   fIndex++;
 620   buf[fIndex]=baseWord;
 621
 622   // Low Voltage measured by FEAC4, FEAC5, FEAC6
 623   fIndex++;
 624   buf[fIndex]=baseWord;
 625
 626   // Low Voltage measured by FEAC1, FEAC2, FEAC3
 627   fIndex++;
 628   buf[fIndex]=baseWord;
 629
 630
 631   baseWord=0;
 632   word = 0; // PDL45 -> Delay Line setting for PDL45
 633   AliBitPacking::PackWord(word,baseWord, 0, 7);
 634   word = 0; // PDL46 -> Delay Line setting for PDL46
 635   AliBitPacking::PackWord(word,baseWord, 8,15);
 636   word = 0; // PDL47 -> Delay Line setting for PDL47
 637   AliBitPacking::PackWord(word,baseWord,16,23);
 638   word = 0; // PDL48 -> Delay Line setting for PDL48
 639   AliBitPacking::PackWord(word,baseWord,24,31);
 640   fIndex++;
 641   buf[fIndex]=baseWord;
 642
 643   // Delay Line setting for PDL41, PDL42, PDL43, PDL44
 644   fIndex++;
 645   buf[fIndex]=baseWord;
 646
 647   // Delay Line setting for PDL37, PDL38, PDL39, PDL40
 648   fIndex++;
 649   buf[fIndex]=baseWord;
 650
 651   // Delay Line setting for PDL33, PDL34, PDL35, PDL36
 652   fIndex++;
 653   buf[fIndex]=baseWord;
 654
 655   // Delay Line setting for PDL29, PDL30, PDL31, PDL32
 656   fIndex++;
 657   buf[fIndex]=baseWord;
 658
 659   // Delay Line setting for PDL25, PDL26, PDL27, PDL28
 660   fIndex++;
 661   buf[fIndex]=baseWord;
 662
 663   // Delay Line setting for PDL21, PDL22, PDL23, PDL24
 664   fIndex++;
 665   buf[fIndex]=baseWord;
 666
 667   // Delay Line setting for PDL17, PDL18, PDL19, PDL20
 668   fIndex++;
 669   buf[fIndex]=baseWord;
 670
 671   // Delay Line setting for PDL13, PDL14, PDL15, PDL16
 672   fIndex++;
 673   buf[fIndex]=baseWord;
 674
 675   // Delay Line setting for PDL9, PDL10, PDL11, PDL12
 676   fIndex++;
 677   buf[fIndex]=baseWord;
 678
 679   // Delay Line setting for PDL5, PDL6, PDL7, PDL8
 680   fIndex++;
 681   buf[fIndex]=baseWord;
 682
 683   // Delay Line setting for PDL1, PDL2, PDL3, PDL4
 684   fIndex++;
 685   buf[fIndex]=baseWord;
 686
 687 }
 688
 689 //----------------------------------------------------------------------------
 690 void AliTOFDDLRawData::MakeLTMtrailer(UInt_t *buf)
 691 {
 692   //
 693   // LTM trailer
 694   //
 695
 696   UInt_t baseWord;
 697   UInt_t word;
 698
 699   baseWord=0;
 700   word = 2; // 0010 -> LTM data are coming from the VME slot number 2
 701   AliBitPacking::PackWord(word,baseWord, 0, 3);
 702   word = 0; // event crc
 703   AliBitPacking::PackWord(word,baseWord, 4,15);
 704   word = 0; // event number
 705   AliBitPacking::PackWord(word,baseWord,16,27);
 706   word = 5; // 0101 -> LTM trailer ID
 707   AliBitPacking::PackWord(word,baseWord,28,31);
 708   fIndex++;
 709   buf[fIndex]=baseWord;
 710
 711 }
 712
 713 //----------------------------------------------------------------------------
 714 void AliTOFDDLRawData::MakeTRMheader(Int_t nTRM, UInt_t *buf)
 715 {
 716   //
 717   // TRM header for the TRM number nTRM [ 3;12]
 718   //
 719
 720   if (nTRM<3 || nTRM>12) {
 721     AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i",nTRM));
 722     return;
 723   }
 724
 725   UInt_t baseWord;
 726   UInt_t word;
 727
 728   baseWord = 0;
 729   word = nTRM; // TRM data coming from the VME slot number nTRM
 730   AliBitPacking::PackWord(word,baseWord, 0, 3);
 731   word = 0; // event words
 732   AliBitPacking::PackWord(word,baseWord, 4,16);
 733
 734   if (fPackedAcquisition)
 735     word = 0; // ACQuisition mode: [0;3] see document
 736   else
 737     word = 3; // ACQuisition mode: [0;3] see document
 738   AliBitPacking::PackWord(word,baseWord,17,18);
 739   word = 0; // description of a SEU inside LUT tables for INL compensation;
 740             // the data are unaffected
 741   AliBitPacking::PackWord(word,baseWord,19,19);
 742   word = 0; // Must Be Zero (MBZ)
 743   AliBitPacking::PackWord(word,baseWord,20,27);
 744   word = 4; // 0100 -> TRM header ID
 745   AliBitPacking::PackWord(word,baseWord,28,31);
 746   fIndex++;
 747   buf[fIndex]=baseWord;
 748
 749 }
 750
 751 //----------------------------------------------------------------------------
 752 void AliTOFDDLRawData::MakeTRMtrailer(UInt_t *buf)
 753 {
 754   //
 755   // TRM trailer
 756   //
 757
 758   UInt_t baseWord;
 759   UInt_t word;
 760
 761   baseWord=0;
 762   word = 15; // 1111 -> TRM trailer ID 1
 763   AliBitPacking::PackWord(word,baseWord, 0, 3);
 764   word = 0; // event CRC
 765   AliBitPacking::PackWord(word,baseWord, 4,15);
 766   word = 0; // local event counter == DRM local event counter
 767   AliBitPacking::PackWord(word,baseWord,16,27);
 768   word = 5; // 0101 -> TRM trailer ID 2
 769   AliBitPacking::PackWord(word,baseWord,28,31);
 770   fIndex++;
 771   buf[fIndex]=baseWord;
 772
 773 }
 774
 775 //----------------------------------------------------------------------------
 776 void AliTOFDDLRawData::MakeTRMchainHeader(Int_t nTRM, Int_t iChain,
 777                                           UInt_t *buf)
 778 {
 779   //
 780   // TRM chain header
 781   //
 782
 783   UInt_t baseWord;
 784   UInt_t word;
 785
 786   if (nTRM<3 || nTRM>12) {
 787     AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i", nTRM));
 788     return;
 789   }
 790
 791   if (iChain<0 || iChain>1) {
 792     AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
 793     return;
 794   }
 795
 796   baseWord=0;
 797   word = nTRM; // TRM data coming from the VME slot ID nTRM
 798   AliBitPacking::PackWord(word,baseWord, 0, 3);
 799   word = 0; // bunch ID
 800   AliBitPacking::PackWord(word,baseWord, 4,15);
 801   word = 100; // PB24 temperature -> 4 X 25 degree (environment temperature)
 802   AliBitPacking::PackWord(word,baseWord,16,23);
 803   word = (Int_t)(5 * gRandom->Rndm()); // PB24 ID [0;4]
 804   AliBitPacking::PackWord(word,baseWord,24,26);
 805   word = 0; // TS
 806   AliBitPacking::PackWord(word,baseWord,27,27);
 807   switch (iChain) {
 808     case 0:
 809       word = 0; // 0000 -> TRM chain 0 ID
 810       break;
 811     case 1:
 812       word = 2; // 0010 -> TRM chain 1 ID
 813       break;
 814     }
 815   AliBitPacking::PackWord(word,baseWord,28,31);
 816   fIndex++;
 817   buf[fIndex]=baseWord;
 818
 819 }
 820
 821 //----------------------------------------------------------------------------
 822 void AliTOFDDLRawData::MakeTRMfiller(UInt_t *buf, UInt_t nWordsPerTRM)
 823 {
 824   //
 825   // TRM filler
 826   //
 827
 828   Int_t jj = -1;
 829
 830   fIndex++;
 831   for (jj=fIndex; jj>fIndex-(Int_t)nWordsPerTRM; jj--) {
 832     buf[jj] = buf[jj-1];
 833   }
 834
 835   buf[fIndex-nWordsPerTRM] = MakeFiller();
 836
 837 }
 838
 839 //----------------------------------------------------------------------------
 840 UInt_t AliTOFDDLRawData::MakeFiller()
 841 {
 842   //
 843   // Filler word definition: to make even the number of words per TRM/LTM
 844   //
 845
 846   UInt_t baseWord;
 847   UInt_t word;
 848
 849   baseWord=0;
 850   word = 0; // 0000 -> filler ID 1
 851   AliBitPacking::PackWord(word,baseWord, 0, 3);
 852   word = 0; // MBZ
 853   AliBitPacking::PackWord(word,baseWord, 4,27);
 854   word = 7; // 0111 -> filler ID 2
 855   AliBitPacking::PackWord(word,baseWord, 28,31);
 856
 857   return baseWord;
 858
 859 }
 860
 861 //----------------------------------------------------------------------------
 862 void AliTOFDDLRawData::MakeTRMchainTrailer(Int_t iChain, UInt_t *buf)
 863 {
 864   //
 865   // TRM chain trailer
 866   //
 867
 868   if (iChain<0 || iChain>1) {
 869     AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
 870     return;
 871   }
 872
 873   UInt_t baseWord;
 874   UInt_t word;
 875
 876   baseWord=0;
 877   word = 0; // status
 878   AliBitPacking::PackWord(word,baseWord, 0, 3);
 879   word = 0; // MBZ
 880   AliBitPacking::PackWord(word,baseWord, 4,15);
 881   word = 0; // event counter
 882   AliBitPacking::PackWord(word,baseWord,16,27);
 883   switch (iChain) {
 884     case 0:
 885       word = 1; // 0001 -> TRM chain 0 trailer ID
 886       break;
 887     case 1:
 888       word = 3; // 0011 -> TRM chain 1 trailer ID
 889       break;
 890     }
 891   AliBitPacking::PackWord(word,baseWord,28,31);
 892   fIndex++;
 893   buf[fIndex]=baseWord;
 894
 895 }
 896
 897 //----------------------------------------------------------------------------
 898 void AliTOFDDLRawData::MakeTDCdigits(Int_t nDDL, Int_t nTRM, Int_t iChain,
 899                                      UInt_t *buf, UInt_t &nWordsPerTRM)
 900 {
 901   //
 902   // TRM TDC digit
 903   //
 904
 905   const Double_t kOneMoreFilledCell = 1./(AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors());
 906   Double_t percentFilledCells = Double_t(fTOFdigitMap->GetFilledCellNumber())/(AliTOFGeometry::NPadXSector()*AliTOFGeometry::NSectors());
 907
 908   if (nDDL<0 || nDDL>71) {
 909     AliWarning(Form(" DDL number is out of the right range [0;71] (nDDL = %3i", nDDL));
 910     return;
 911   }
 912
 913   if (nTRM<3 || nTRM>12) {
 914     AliWarning(Form(" TRM number is out of the right range [3;12] (nTRM = %3i", nTRM));
 915     return;
 916   }
 917
 918   if (iChain<0 || iChain>1) {
 919     AliWarning(Form(" Chain number is out of the right range [0;1] (iChain = %3i", iChain));
 920     return;
 921   }
 922
 923   Int_t psArray[1000];
 924   UInt_t localBuffer[1000];
 925   Int_t localIndex = -1;
 926
 927   Int_t iDDL = nDDL%AliTOFGeometry::NDDL();
 928
 929   Int_t volume[5] = {-1, -1, -1, -1, -1};
 930   Int_t indexDigit[3] = {-1, -1, -1};
 931
 932   Int_t totCharge = -1;
 933   Int_t timeOfFlight = -1;
 934
 935   Int_t trailingSpurious = -1;
 936   Int_t leadingSpurious = -1;
 937
 938   AliTOFdigit *digs;
 939
 940   UInt_t baseWord=0;
 941   UInt_t word=0;
 942
 943   Int_t jj = -1;
 944   Int_t nTDC = -1;
 945   Int_t iCH = -1;
 946
 947   //Int_t numberOfMeasuresPerChannel = 0;
 948   //Int_t maxMeasuresPerChannelInTDC = 0;
 949
 950   Bool_t outOut = HeadOrTail();
 951
 952   ofstream ftxt;
 953
 954   if (fVerbose==2) ftxt.open("TOFdigits.txt",ios::app);
 955
 956   for (jj=0; jj<5; jj++) volume[jj] = -1;
 957
 958   // loop on TDC number
 959   for (nTDC=AliTOFGeometry::NTdc()-1; nTDC>=0; nTDC--) {
 960
 961     // the DRM odd (i.e. left) slot number 3 doesn't contain TDC digit data
 962     // for TDC numbers 3-14
 963     if (iDDL%2==1 && nTRM==3 && (Int_t)(nTDC/3.)!=0) continue;
 964
 965     // loop on TDC channel number
 966     for (iCH=AliTOFGeometry::NCh()-1; iCH>=0; iCH--) {
 967
 968       //numberOfMeasuresPerChannel = 0;
 969
 970       //fTOFrawStream->EquipmentId2VolumeId(nDDL, nTRM, iChain, nTDC, iCH, volume);
 971       AliTOFRawStream::EquipmentId2VolumeId(nDDL, nTRM, iChain, nTDC, iCH, volume);
 972
 973       if (volume[0]==-1 || volume[1]==-1 || volume[2]==-1 ||
 974           volume[3]==-1 || volume[4]==-1) continue;
 975
 976       for (jj=0; jj<3; jj++) indexDigit[jj] = -1;
 977
 978       fTOFdigitMap->GetDigitIndex(volume, indexDigit);
 979
 980       if (indexDigit[0]<0) {
 981
 982         trailingSpurious = Int_t(2097152*gRandom->Rndm());
 983         leadingSpurious = Int_t(2097152*gRandom->Rndm());
 984
 985         if ( fFakeOrphaneProduction &&
 986              ( ( fPackedAcquisition && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) ||
 987                (!fPackedAcquisition && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) )  )  ) {
 988
 989           percentFilledCells+=kOneMoreFilledCell;
 990
 991           Int_t dummyPS = 0;
 992
 993           if (outOut) {
 994             word = trailingSpurious; // trailing edge measurement
 995             dummyPS = 2;
 996           }
 997           else {
 998             word = leadingSpurious; // leading edge measurement
 999             dummyPS = 1;
1000           }
1001
1002           if (fVerbose==2) {
1003             if (nDDL<10) ftxt << "  " << nDDL;
1004             else         ftxt << " " << nDDL;
1005             if (nTRM<10) ftxt << "  " << nTRM;
1006             else         ftxt << " " << nTRM;
1007             ftxt << "  " << iChain;
1008             if (nTDC<10) ftxt << "  " << nTDC;
1009             else         ftxt << " " << nTDC;
1010             ftxt << "  " << iCH;
1011             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1012             else              ftxt  << "  -> " << volume[0];
1013             ftxt << "  " << volume[1];
1014             if (volume[2]<10) ftxt << "  " << volume[2];
1015             else              ftxt << " " << volume[2];
1016             ftxt << "  " << volume[4];
1017             if (volume[3]<10) ftxt << "  " << volume[3];
1018             else              ftxt << " " << volume[3];
1019             ftxt << "   " << -1;
1020             if (word<10)                           ftxt << "        " << word;
1021             else if (word>=10     && word<100)     ftxt << "       " << word;
1022             else if (word>=100    && word<1000)    ftxt << "      " << word;
1023             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1024             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1025             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1026             else                                   ftxt << "  " << word;
1027             ftxt << "   " << dummyPS << endl;
1028           }
1029
1030           AliBitPacking::PackWord(word,baseWord, 0,20);
1031           word = iCH; // TDC channel ID [0;7]
1032           AliBitPacking::PackWord(word,baseWord,21,23);
1033           word = nTDC; // TDC ID [0;14]
1034           AliBitPacking::PackWord(word,baseWord,24,27);
1035           word = 0; // error flag
1036           AliBitPacking::PackWord(word,baseWord,28,28);
1037           word = dummyPS; // Packing Status [0;3]
1038           AliBitPacking::PackWord(word,baseWord,29,30);
1039           word = 1; // TRM TDC digit ID
1040           AliBitPacking::PackWord(word,baseWord,31,31);
1041
1042           localIndex++;
1043           localBuffer[localIndex]=baseWord;
1044           psArray[localIndex]=dummyPS;
1045
1046           nWordsPerTRM++;
1047           baseWord=0;
1048
1049         } // if ( fFakeOrphaneProduction && ( ( fPackedAcquisition && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) or ... ) )
1050       } // if (indexDigit[0]<0)
1051
1052       for (jj=0; jj<3;jj++) {
1053
1054         if (indexDigit[jj]<0) continue;
1055
1056         digs = (AliTOFdigit*)fTOFdigitArray->UncheckedAt(indexDigit[jj]);
1057
1058         if (digs->GetSector()!=volume[0] ||
1059             digs->GetPlate() !=volume[1] ||
1060             digs->GetStrip() !=volume[2] ||
1061             digs->GetPadx()  !=volume[3] ||
1062             digs->GetPadz()  !=volume[4]) AliWarning(Form(" --- ERROR --- %2i (%2i)  %1i (%1i)  %2i (%2i)  %2i (%2i)  %1i (%1i)",
1063                                                           digs->GetSector(), volume[0],
1064                                                           digs->GetPlate(), volume[1],
1065                                                           digs->GetStrip(), volume[2],
1066                                                           digs->GetPadx(), volume[3],
1067                                                           digs->GetPadz(), volume[4])
1068                                                      );
1069
1070         timeOfFlight = (Int_t)(digs->GetTdc())
1071           /*+
1072           fTOFCableLengthMap->GetCableTimeShiftBin(nDDL, nTRM, iChain, nTDC)*/;
1073
1074         //if (timeOfFlight>=fMatchingWindow+1000) continue; // adc
1075         if (timeOfFlight>=fMatchingWindow) continue; // adc
1076
1077         //numberOfMeasuresPerChannel++;
1078
1079         // totCharge = (Int_t)digs->GetAdc(); //Use realistic ToT, for Standard production with no miscalibration/Slewing it == fAdC in digit (see AliTOFDigitizer)
1080         totCharge = (Int_t)(digs->GetToT());
1081         // temporary control
1082         if (totCharge<0) totCharge = 0;//TMath::Abs(totCharge);
1083
1084         if (fPackedAcquisition) {
1085
1086         if (fVerbose==2) {
1087           if (nDDL<10) ftxt << "  " << nDDL;
1088           else         ftxt << " " << nDDL;
1089           if (nTRM<10) ftxt << "  " << nTRM;
1090           else         ftxt << " " << nTRM;
1091           ftxt << "  " << iChain;
1092           if (nTDC<10) ftxt << "  " << nTDC;
1093           else         ftxt << " " << nTDC;
1094           ftxt << "  " << iCH;
1095           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1096           else              ftxt  << "  -> " << volume[0];
1097           ftxt << "  " << volume[1];
1098           if (volume[2]<10) ftxt << "  " << volume[2];
1099           else              ftxt << " " << volume[2];
1100           ftxt << "  " << volume[4];
1101           if (volume[3]<10) ftxt << "  " << volume[3];
1102           else              ftxt << " " << volume[3];
1103           if (totCharge<10)                        ftxt << "    " << totCharge;
1104           else if (totCharge>=10 && totCharge<100) ftxt << "   " << totCharge;
1105           else                                     ftxt << "  " << totCharge;
1106           if (timeOfFlight<10)                             ftxt << "     " << timeOfFlight << endl;
1107           else if (timeOfFlight>=10  && timeOfFlight<100)  ftxt << "    " << timeOfFlight << endl;
1108           else if (timeOfFlight>=100 && timeOfFlight<1000) ftxt << "   " << timeOfFlight << endl;
1109           else                                             ftxt << "  " << timeOfFlight << endl;
1110         }
1111
1112         word = timeOfFlight%8192; // time-of-fligth measurement
1113         AliBitPacking::PackWord(word,baseWord, 0,12);
1114
1115         if (totCharge>=256) totCharge = 255;
1116         word = totCharge; // time-over-threshould measurement
1117         AliBitPacking::PackWord(word,baseWord,13,20);
1118
1119         word = iCH; // TDC channel ID [0;7]
1120         AliBitPacking::PackWord(word,baseWord,21,23);
1121         word = nTDC; // TDC ID [0;14]
1122         AliBitPacking::PackWord(word,baseWord,24,27);
1123         word = 0; // error flag
1124         AliBitPacking::PackWord(word,baseWord,28,28);
1125         word = 0; // Packing Status [0;3]
1126         AliBitPacking::PackWord(word,baseWord,29,30);
1127         word = 1; // TRM TDC digit ID
1128         AliBitPacking::PackWord(word,baseWord,31,31);
1129
1130         localIndex++;
1131         localBuffer[localIndex]=baseWord;
1132
1133         nWordsPerTRM++;
1134         baseWord=0;
1135
1136         if ( fFakeOrphaneProduction &&
1137              percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) {
1138
1139           percentFilledCells+=kOneMoreFilledCell;
1140
1141           trailingSpurious = Int_t(2097152*gRandom->Rndm());
1142           leadingSpurious = Int_t(2097152*gRandom->Rndm());
1143
1144           Int_t dummyPS = 0;
1145
1146           if (outOut) {
1147             word = trailingSpurious; // trailing edge measurement
1148             dummyPS = 2;
1149           }
1150           else {
1151             word = leadingSpurious; // leading edge measurement
1152             dummyPS = 1;
1153           }
1154
1155           if (fVerbose==2) {
1156             if (nDDL<10) ftxt << "  " << nDDL;
1157             else         ftxt << " " << nDDL;
1158             if (nTRM<10) ftxt << "  " << nTRM;
1159             else         ftxt << " " << nTRM;
1160             ftxt << "  " << iChain;
1161             if (nTDC<10) ftxt << "  " << nTDC;
1162             else         ftxt << " " << nTDC;
1163             ftxt << "  " << iCH;
1164             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1165             else              ftxt  << "  -> " << volume[0];
1166             ftxt << "  " << volume[1];
1167             if (volume[2]<10) ftxt << "  " << volume[2];
1168             else              ftxt << " " << volume[2];
1169             ftxt << "  " << volume[4];
1170             if (volume[3]<10) ftxt << "  " << volume[3];
1171             else              ftxt << " " << volume[3];
1172             ftxt << "   " << -1;
1173             if (word<10)                           ftxt << "        " << word;
1174             else if (word>=10     && word<100)     ftxt << "       " << word;
1175             else if (word>=100    && word<1000)    ftxt << "      " << word;
1176             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1177             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1178             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1179             else                                   ftxt << "  " << word;
1180             ftxt << "   " << dummyPS << endl;
1181           }
1182
1183           AliBitPacking::PackWord(word,baseWord, 0,20);
1184           word = iCH; // TDC channel ID [0;7]
1185           AliBitPacking::PackWord(word,baseWord,21,23);
1186           word = nTDC; // TDC ID [0;14]
1187           AliBitPacking::PackWord(word,baseWord,24,27);
1188           word = 0; // error flag
1189           AliBitPacking::PackWord(word,baseWord,28,28);
1190           word = dummyPS; // Packing Status [0;3]
1191           AliBitPacking::PackWord(word,baseWord,29,30);
1192           word = 1; // TRM TDC digit ID
1193           AliBitPacking::PackWord(word,baseWord,31,31);
1194
1195           localIndex++;
1196           localBuffer[localIndex]=baseWord;
1197           psArray[localIndex]=dummyPS;
1198
1199           nWordsPerTRM++;
1200           baseWord=0;
1201
1202         } // if ( fFakeOrphaneProduction && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) )
1203
1204
1205         } // if (fPackedAcquisition)
1206         else { // if (!fPackedAcquisition)
1207
1208         if ( fFakeOrphaneProduction &&
1209              percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && outOut ) {
1210
1211           percentFilledCells+=kOneMoreFilledCell;
1212
1213           trailingSpurious = Int_t(2097152*gRandom->Rndm());
1214           word = trailingSpurious;
1215           Int_t dummyPS = 2;
1216
1217           if (fVerbose==2) {
1218             if (nDDL<10) ftxt << "  " << nDDL;
1219             else         ftxt << " " << nDDL;
1220             if (nTRM<10) ftxt << "  " << nTRM;
1221             else         ftxt << " " << nTRM;
1222             ftxt << "  " << iChain;
1223             if (nTDC<10) ftxt << "  " << nTDC;
1224             else         ftxt << " " << nTDC;
1225             ftxt << "  " << iCH;
1226             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1227             else              ftxt  << "  -> " << volume[0];
1228             ftxt << "  " << volume[1];
1229             if (volume[2]<10) ftxt << "  " << volume[2];
1230             else              ftxt << " " << volume[2];
1231             ftxt << "  " << volume[4];
1232             if (volume[3]<10) ftxt << "  " << volume[3];
1233             else              ftxt << " " << volume[3];
1234             ftxt << "   " << -1;
1235             if (word<10)                           ftxt << "        " << word;
1236             else if (word>=10     && word<100)     ftxt << "       " << word;
1237             else if (word>=100    && word<1000)    ftxt << "      " << word;
1238             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1239             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1240             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1241             else                                   ftxt << "  " << word;
1242             ftxt << "   " << dummyPS << endl;
1243           }
1244
1245           AliBitPacking::PackWord(word,baseWord, 0,20);
1246           word = iCH; // TDC channel ID [0;7]
1247           AliBitPacking::PackWord(word,baseWord,21,23);
1248           word = nTDC; // TDC ID [0;14]
1249           AliBitPacking::PackWord(word,baseWord,24,27);
1250           word = 0; // error flag
1251           AliBitPacking::PackWord(word,baseWord,28,28);
1252           word = dummyPS; // Packing Status [0;3]
1253           AliBitPacking::PackWord(word,baseWord,29,30);
1254           word = 1; // TRM TDC digit ID
1255           AliBitPacking::PackWord(word,baseWord,31,31);
1256
1257           localIndex++;
1258           localBuffer[localIndex]=baseWord;
1259           psArray[localIndex]=dummyPS;
1260
1261           nWordsPerTRM++;
1262           baseWord=0;
1263
1264         } // if ( fFakeOrphaneProduction && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells)  && outOut )
1265
1266
1267         word = (timeOfFlight + Int_t(totCharge*AliTOFGeometry::ToTBinWidth()/AliTOFGeometry::TdcBinWidth()))%2097152; // trailing edge measurement
1268
1269         if (fVerbose==2) {
1270           if (nDDL<10) ftxt << "  " << nDDL;
1271           else         ftxt << " " << nDDL;
1272           if (nTRM<10) ftxt << "  " << nTRM;
1273           else         ftxt << " " << nTRM;
1274           ftxt << "  " << iChain;
1275           if (nTDC<10) ftxt << "  " << nTDC;
1276           else         ftxt << " " << nTDC;
1277           ftxt << "  " << iCH;
1278           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1279           else              ftxt  << "  -> " << volume[0];
1280           ftxt << "  " << volume[1];
1281           if (volume[2]<10) ftxt << "  " << volume[2];
1282           else              ftxt << " " << volume[2];
1283           ftxt << "  " << volume[4];
1284           if (volume[3]<10) ftxt << "  " << volume[3];
1285           else              ftxt << " " << volume[3];
1286           ftxt << "   " << -1;
1287           if (word<10)                           ftxt << "        " << word;
1288           else if (word>=10     && word<100)     ftxt << "       " << word;
1289           else if (word>=100    && word<1000)    ftxt << "      " << word;
1290           else if (word>=1000   && word<10000)   ftxt << "     " << word;
1291           else if (word>=10000  && word<100000)  ftxt << "    " << word;
1292           else if (word>=100000 && word<1000000) ftxt << "   " << word;
1293           else                                   ftxt << "  " << word;
1294           ftxt << "   " << 2 << endl;
1295         }
1296
1297         AliBitPacking::PackWord(word,baseWord, 0,20);
1298
1299         word = iCH; // TDC channel ID [0;7]
1300         AliBitPacking::PackWord(word,baseWord,21,23);
1301         word = nTDC; // TDC ID [0;14]
1302         AliBitPacking::PackWord(word,baseWord,24,27);
1303         word = 0; // error flag
1304         AliBitPacking::PackWord(word,baseWord,28,28);
1305         word = 2; // Packing Status [0;3]
1306         AliBitPacking::PackWord(word,baseWord,29,30);
1307         word = 1; // TRM TDC digit ID
1308         AliBitPacking::PackWord(word,baseWord,31,31);
1309
1310         localIndex++;
1311         localBuffer[localIndex]=baseWord;
1312         psArray[localIndex]=2;
1313
1314         nWordsPerTRM++;
1315         baseWord=0;
1316
1317         word = timeOfFlight%2097152; // leading edge measurement
1318
1319         if (fVerbose==2) {
1320           if (nDDL<10) ftxt << "  " << nDDL;
1321           else         ftxt << " " << nDDL;
1322           if (nTRM<10) ftxt << "  " << nTRM;
1323           else         ftxt << " " << nTRM;
1324           ftxt << "  " << iChain;
1325           if (nTDC<10) ftxt << "  " << nTDC;
1326           else         ftxt << " " << nTDC;
1327           ftxt << "  " << iCH;
1328           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1329           else              ftxt  << "  -> " << volume[0];
1330           ftxt << "  " << volume[1];
1331           if (volume[2]<10) ftxt << "  " << volume[2];
1332           else              ftxt << " " << volume[2];
1333           ftxt << "  " << volume[4];
1334           if (volume[3]<10) ftxt << "  " << volume[3];
1335           else              ftxt << " " << volume[3];
1336           ftxt << "   " << -1;
1337           if (word<10)                           ftxt << "        " << word;
1338           else if (word>=10     && word<100)     ftxt << "       " << word;
1339           else if (word>=100    && word<1000)    ftxt << "      " << word;
1340           else if (word>=1000   && word<10000)   ftxt << "     " << word;
1341           else if (word>=10000  && word<100000)  ftxt << "    " << word;
1342           else if (word>=100000 && word<1000000) ftxt << "   " << word;
1343           else                                   ftxt << "  " << word;
1344           ftxt << "   " << 1 << endl;
1345         }
1346
1347         AliBitPacking::PackWord(word,baseWord, 0,20);
1348
1349         word = iCH; // TDC channel ID [0;7]
1350         AliBitPacking::PackWord(word,baseWord,21,23);
1351         word = nTDC; // TDC ID [0;14]
1352         AliBitPacking::PackWord(word,baseWord,24,27);
1353         word = 0; // error flag
1354         AliBitPacking::PackWord(word,baseWord,28,28);
1355         word = 1; // Packing Status [0;3]
1356         AliBitPacking::PackWord(word,baseWord,29,30);
1357         word = 1; // TRM TDC digit ID
1358         AliBitPacking::PackWord(word,baseWord,31,31);
1359
1360         localIndex++;
1361         localBuffer[localIndex]=baseWord;
1362         psArray[localIndex]=1;
1363
1364         nWordsPerTRM++;
1365         baseWord=0;
1366
1367
1368         if ( fFakeOrphaneProduction &&
1369              percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && !outOut ) {
1370
1371           percentFilledCells+=kOneMoreFilledCell;
1372
1373           leadingSpurious = Int_t(2097152*gRandom->Rndm());
1374           word = leadingSpurious;
1375           Int_t dummyPS = 1;
1376
1377           if (fVerbose==2) {
1378             if (nDDL<10) ftxt << "  " << nDDL;
1379             else         ftxt << " " << nDDL;
1380             if (nTRM<10) ftxt << "  " << nTRM;
1381             else         ftxt << " " << nTRM;
1382             ftxt << "  " << iChain;
1383             if (nTDC<10) ftxt << "  " << nTDC;
1384             else         ftxt << " " << nTDC;
1385             ftxt << "  " << iCH;
1386             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1387             else              ftxt  << "  -> " << volume[0];
1388             ftxt << "  " << volume[1];
1389             if (volume[2]<10) ftxt << "  " << volume[2];
1390             else              ftxt << " " << volume[2];
1391             ftxt << "  " << volume[4];
1392             if (volume[3]<10) ftxt << "  " << volume[3];
1393             else              ftxt << " " << volume[3];
1394             ftxt << "   " << -1;
1395             if (word<10)                           ftxt << "        " << word;
1396             else if (word>=10     && word<100)     ftxt << "       " << word;
1397             else if (word>=100    && word<1000)    ftxt << "      " << word;
1398             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1399             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1400             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1401             else                                   ftxt << "  " << word;
1402             ftxt << "   " << dummyPS << endl;
1403           }
1404
1405           AliBitPacking::PackWord(word,baseWord, 0,20);
1406           word = iCH; // TDC channel ID [0;7]
1407           AliBitPacking::PackWord(word,baseWord,21,23);
1408           word = nTDC; // TDC ID [0;14]
1409           AliBitPacking::PackWord(word,baseWord,24,27);
1410           word = 0; // error flag
1411           AliBitPacking::PackWord(word,baseWord,28,28);
1412           word = dummyPS; // Packing Status [0;3]
1413           AliBitPacking::PackWord(word,baseWord,29,30);
1414           word = 1; // TRM TDC digit ID
1415           AliBitPacking::PackWord(word,baseWord,31,31);
1416
1417           localIndex++;
1418           localBuffer[localIndex]=baseWord;
1419           psArray[localIndex]=dummyPS;
1420
1421           nWordsPerTRM++;
1422           baseWord=0;
1423
1424         } // if ( fFakeOrphaneProduction && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && !outOut )
1425
1426
1427         } // if (!fPackedAcquisition)
1428
1429       } //end loop on digits in the same volume
1430
1431       //if (numberOfMeasuresPerChannel>maxMeasuresPerChannelInTDC)
1432       //maxMeasuresPerChannelInTDC = numberOfMeasuresPerChannel;
1433
1434     } // end loop on TDC channel number
1435
1436     //AliInfo(Form(" TDC number %2i:  numberOfMeasuresPerChannel = %2i  ---  maxMeasuresPerChannelInTDC = %2i ", nTDC, numberOfMeasuresPerChannel, maxMeasuresPerChannelInTDC));
1437
1438     if (localIndex==-1) continue;
1439
1440     if (fPackedAcquisition) {
1441
1442       for (jj=0; jj<=localIndex; jj++) {
1443         fIndex++;
1444         buf[fIndex] = localBuffer[jj];
1445         localBuffer[jj] = 0;
1446         psArray[jj] = -1;
1447       }
1448
1449     }
1450     else {
1451       /*
1452       if (maxMeasuresPerChannelInTDC = 1) {
1453
1454         for (Int_t jj=0; jj<=localIndex; jj++) {
1455           if (psArray[jj]==2) {
1456             fIndex++;
1457             buf[fIndex] = localBuffer[jj];
1458             localBuffer[jj] = 0;
1459             psArray[jj] = -1;
1460           }
1461         }
1462         for (Int_t jj=0; jj<=localIndex; jj++) {
1463           if (psArray[jj]==1) {
1464             fIndex++;
1465             buf[fIndex] = localBuffer[jj];
1466             localBuffer[jj] = 0;
1467             psArray[jj] = -1;
1468           }
1469         }
1470
1471       } // if (maxMeasuresPerChannelInTDC = 1)
1472       else if (maxMeasuresPerChannelInTDC>1) {
1473
1474         AliInfo(Form(" In the TOF DDL %2i, TRM %2i, TDC %2i, chain %1i, the maximum number of t.o.f. good measurements per channel is %2i",
1475                      nDDL, nTRM, iChain, nTDC, iCH, maxMeasuresPerChannelInTDC));
1476       */
1477       for (jj=0; jj<=localIndex; jj++) {
1478             fIndex++;
1479             buf[fIndex] = localBuffer[jj];
1480             localBuffer[jj] = 0;
1481             psArray[jj] = -1;
1482         }
1483
1484         //} // else if (maxMeasuresPerChannelInTDC>1)
1485
1486     } // else (!fPackedAcquisition)
1487
1488     localIndex = -1;
1489
1490     //maxMeasuresPerChannelInTDC = 0;
1491
1492   } // end loop on TDC number
1493
1494
1495   if (fVerbose==2) ftxt.close();
1496
1497 }
1498
1499 //----------------------------------------------------------------------------
1500 void AliTOFDDLRawData::ReverseArray(UInt_t a[], Int_t n) const
1501 {
1502   //
1503   // Reverses the n elements of array a
1504   //
1505
1506   Int_t ii, temp;
1507
1508   for (ii=0; ii<n/2; ii++) {
1509     temp      = a[ii];
1510     a[ii]     = a[n-ii-1];
1511     a[n-ii-1] = temp;
1512   }
1513
1514   return;
1515
1516 }
1517
1518 //----------------------------------------------------------------------------
1519 Bool_t AliTOFDDLRawData::HeadOrTail() const
1520 {
1521   //
1522   // Returns the result of a 'pitch and toss'
1523   //
1524
1525   Double_t dummy = gRandom->Rndm();
1526
1527   if (dummy<0.5) return kFALSE;
1528   else return kTRUE;
1529
1530 }