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