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