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