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   Int_t psArray[1000];
1032   UInt_t localBuffer[1000];
1033   Int_t localIndex = -1;
1034
1035   Int_t iDDL = nDDL%AliTOFGeometry::NDDL();
1036
1037   Int_t volume[5] = {-1, -1, -1, -1, -1};
1038   Int_t indexDigit[3] = {-1, -1, -1};
1039
1040   Int_t totCharge = -1;
1041   Int_t timeOfFlight = -1;
1042
1043   Int_t trailingSpurious = -1;
1044   Int_t leadingSpurious = -1;
1045
1046   AliTOFdigit *digs;
1047
1048   UInt_t baseWord=0;
1049   UInt_t word=0;
1050
1051   Int_t jj = -1;
1052   Int_t nTDC = -1;
1053   Int_t iCH = -1;
1054
1055   //Int_t numberOfMeasuresPerChannel = 0;
1056   //Int_t maxMeasuresPerChannelInTDC = 0;
1057
1058   Bool_t outOut = HeadOrTail();
1059
1060   ofstream ftxt;
1061
1062   if (fVerbose==2) ftxt.open("TOFdigits.txt",ios::app);
1063
1064   for (jj=0; jj<5; jj++) volume[jj] = -1;
1065
1066   // loop on TDC number
1067   for (nTDC=AliTOFGeometry::NTdc()-1; nTDC>=0; nTDC--) {
1068
1069     // the DRM odd (i.e. left) slot number 3 doesn't contain TDC digit data
1070     // for TDC numbers 3-14
1071     if (iDDL%2==1 && nTRM==3 && (Int_t)(nTDC/3)!=0) continue;
1072
1073     // loop on TDC channel number
1074     for (iCH=AliTOFGeometry::NCh()-1; iCH>=0; iCH--) {
1075
1076       //numberOfMeasuresPerChannel = 0;
1077
1078       for (Int_t aa=0; aa<5; aa++) volume[aa]=-1;
1079       AliTOFRawStream::EquipmentId2VolumeId(nDDL, nTRM, iChain, nTDC, iCH, volume);
1080
1081       AliDebug(3,Form(" volume -> %2d %1d %2d %2d %1d",volume[0],volume[1],volume[2],volume[3],volume[4]));
1082
1083       if (volume[0]==-1 || volume[1]==-1 || volume[2]==-1 ||
1084           volume[3]==-1 || volume[4]==-1) continue;
1085
1086       AliDebug(3,Form(" ====== %2d %1d %2d %2d %1d",volume[0],volume[1],volume[2],volume[3],volume[4]));
1087
1088       for (jj=0; jj<3; jj++) indexDigit[jj] = -1;
1089
1090       fTOFdigitMap->GetDigitIndex(volume, indexDigit);
1091
1092       if (indexDigit[0]<0) {
1093
1094         trailingSpurious = Int_t(2097152*gRandom->Rndm());
1095         leadingSpurious = Int_t(2097152*gRandom->Rndm());
1096
1097         if ( fFakeOrphaneProduction &&
1098              ( ( fPackedAcquisition && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) ||
1099                (!fPackedAcquisition && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) )  )  ) {
1100
1101           percentFilledCells+=kOneMoreFilledCell;
1102
1103           Int_t dummyPS = 0;
1104
1105           if (outOut) {
1106             word = trailingSpurious; // trailing edge measurement
1107             dummyPS = 2;
1108           }
1109           else {
1110             word = leadingSpurious; // leading edge measurement
1111             dummyPS = 1;
1112           }
1113
1114           if (fVerbose==2) {
1115             if (nDDL<10) ftxt << "  " << nDDL;
1116             else         ftxt << " " << nDDL;
1117             if (nTRM<10) ftxt << "  " << nTRM;
1118             else         ftxt << " " << nTRM;
1119             ftxt << "  " << iChain;
1120             if (nTDC<10) ftxt << "  " << nTDC;
1121             else         ftxt << " " << nTDC;
1122             ftxt << "  " << iCH;
1123             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1124             else              ftxt  << "  -> " << volume[0];
1125             ftxt << "  " << volume[1];
1126             if (volume[2]<10) ftxt << "  " << volume[2];
1127             else              ftxt << " " << volume[2];
1128             ftxt << "  " << volume[4];
1129             if (volume[3]<10) ftxt << "  " << volume[3];
1130             else              ftxt << " " << volume[3];
1131             ftxt << "   " << -1;
1132             if (word<10)                           ftxt << "        " << word;
1133             else if (word>=10     && word<100)     ftxt << "       " << word;
1134             else if (word>=100    && word<1000)    ftxt << "      " << word;
1135             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1136             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1137             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1138             else                                   ftxt << "  " << word;
1139             ftxt << "   " << dummyPS << endl;
1140           }
1141
1142           AliBitPacking::PackWord(word,baseWord, 0,20);
1143           word = iCH; // TDC channel ID [0;7]
1144           AliBitPacking::PackWord(word,baseWord,21,23);
1145           word = nTDC; // TDC ID [0;14]
1146           AliBitPacking::PackWord(word,baseWord,24,27);
1147           word = 0; // error flag
1148           AliBitPacking::PackWord(word,baseWord,28,28);
1149           word = dummyPS; // Packing Status [0;3]
1150           AliBitPacking::PackWord(word,baseWord,29,30);
1151           word = 1; // TRM TDC digit ID
1152           AliBitPacking::PackWord(word,baseWord,31,31);
1153
1154           localIndex++; fWordsPerTRM++;
1155           localBuffer[localIndex]=baseWord;
1156           psArray[localIndex]=dummyPS;
1157
1158           baseWord=0;
1159
1160         } // if ( fFakeOrphaneProduction && ( ( fPackedAcquisition && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) or ... ) )
1161       } // if (indexDigit[0]<0)
1162
1163       for (jj=0; jj<3;jj++) {
1164
1165         if (indexDigit[jj]<0) continue;
1166
1167         AliDebug(3,Form(" ====== %2d %1d %2d %2d %1d -> %1d %d",volume[0],volume[1],volume[2],volume[3],volume[4],jj,indexDigit[jj]));
1168
1169         digs = (AliTOFdigit*)fTOFdigitArray->UncheckedAt(indexDigit[jj]);
1170
1171         if (digs->GetSector()!=volume[0] ||
1172             digs->GetPlate() !=volume[1] ||
1173             digs->GetStrip() !=volume[2] ||
1174             digs->GetPadx()  !=volume[3] ||
1175             digs->GetPadz()  !=volume[4]) AliWarning(Form(" --- ERROR --- %2i (%2i)  %1i (%1i)  %2i (%2i)  %2i (%2i)  %1i (%1i)",
1176                                                           digs->GetSector(), volume[0],
1177                                                           digs->GetPlate(), volume[1],
1178                                                           digs->GetStrip(), volume[2],
1179                                                           digs->GetPadx(), volume[3],
1180                                                           digs->GetPadz(), volume[4])
1181                                                      );
1182
1183         timeOfFlight = (Int_t)(digs->GetTdc());
1184         /*+
1185           fTOFCableLengthMap->GetCableTimeShiftBin(nDDL, nTRM, iChain, nTDC)*/;
1186
1187         //if (timeOfFlight>=fMatchingWindow+1000) continue; // adc
1188         //if (timeOfFlight>=fMatchingWindow) continue; // adc
1189         if (digs->GetTdcND()>=fMatchingWindow) {
1190           AliDebug(2,"Out of matching window.");
1191           continue; // adc
1192         }
1193         else AliDebug(2,"In matching window");
1194
1195         //numberOfMeasuresPerChannel++;
1196
1197         // totCharge = (Int_t)digs->GetAdc(); //Use realistic ToT, for Standard production with no miscalibration/Slewing it == fAdC in digit (see AliTOFDigitizer)
1198         totCharge = (Int_t)(digs->GetToT());
1199         // temporary control
1200         if (totCharge<0) totCharge = 0;//TMath::Abs(totCharge);
1201
1202         if (fPackedAcquisition) {
1203
1204         if (fVerbose==2) {
1205           if (nDDL<10) ftxt << "  " << nDDL;
1206           else         ftxt << " " << nDDL;
1207           if (nTRM<10) ftxt << "  " << nTRM;
1208           else         ftxt << " " << nTRM;
1209           ftxt << "  " << iChain;
1210           if (nTDC<10) ftxt << "  " << nTDC;
1211           else         ftxt << " " << nTDC;
1212           ftxt << "  " << iCH;
1213           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1214           else              ftxt  << "  -> " << volume[0];
1215           ftxt << "  " << volume[1];
1216           if (volume[2]<10) ftxt << "  " << volume[2];
1217           else              ftxt << " " << volume[2];
1218           ftxt << "  " << volume[4];
1219           if (volume[3]<10) ftxt << "  " << volume[3];
1220           else              ftxt << " " << volume[3];
1221           if (totCharge<10)                        ftxt << "    " << totCharge;
1222           else if (totCharge>=10 && totCharge<100) ftxt << "   " << totCharge;
1223           else                                     ftxt << "  " << totCharge;
1224           if (timeOfFlight<10)                             ftxt << "     " << timeOfFlight << endl;
1225           else if (timeOfFlight>=10  && timeOfFlight<100)  ftxt << "    " << timeOfFlight << endl;
1226           else if (timeOfFlight>=100 && timeOfFlight<1000) ftxt << "   " << timeOfFlight << endl;
1227           else                                             ftxt << "  " << timeOfFlight << endl;
1228         }
1229
1230         word = timeOfFlight%8192; // time-of-fligth measurement
1231         AliBitPacking::PackWord(word,baseWord, 0,12);
1232
1233         if (totCharge>=256) totCharge = 255;
1234         word = totCharge; // time-over-threshould measurement
1235         AliBitPacking::PackWord(word,baseWord,13,20);
1236
1237         word = iCH; // TDC channel ID [0;7]
1238         AliBitPacking::PackWord(word,baseWord,21,23);
1239         word = nTDC; // TDC ID [0;14]
1240         AliBitPacking::PackWord(word,baseWord,24,27);
1241         word = 0; // error flag
1242         AliBitPacking::PackWord(word,baseWord,28,28);
1243         word = 0; // Packing Status [0;3]
1244         AliBitPacking::PackWord(word,baseWord,29,30);
1245         word = 1; // TRM TDC digit ID
1246         AliBitPacking::PackWord(word,baseWord,31,31);
1247
1248         localIndex++; fWordsPerTRM++;
1249         localBuffer[localIndex]=baseWord;
1250
1251         baseWord=0;
1252
1253         if ( fFakeOrphaneProduction &&
1254              percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) ) {
1255
1256           percentFilledCells+=kOneMoreFilledCell;
1257
1258           trailingSpurious = Int_t(2097152*gRandom->Rndm());
1259           leadingSpurious = Int_t(2097152*gRandom->Rndm());
1260
1261           Int_t dummyPS = 0;
1262
1263           if (outOut) {
1264             word = trailingSpurious; // trailing edge measurement
1265             dummyPS = 2;
1266           }
1267           else {
1268             word = leadingSpurious; // leading edge measurement
1269             dummyPS = 1;
1270           }
1271
1272           if (fVerbose==2) {
1273             if (nDDL<10) ftxt << "  " << nDDL;
1274             else         ftxt << " " << nDDL;
1275             if (nTRM<10) ftxt << "  " << nTRM;
1276             else         ftxt << " " << nTRM;
1277             ftxt << "  " << iChain;
1278             if (nTDC<10) ftxt << "  " << nTDC;
1279             else         ftxt << " " << nTDC;
1280             ftxt << "  " << iCH;
1281             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1282             else              ftxt  << "  -> " << volume[0];
1283             ftxt << "  " << volume[1];
1284             if (volume[2]<10) ftxt << "  " << volume[2];
1285             else              ftxt << " " << volume[2];
1286             ftxt << "  " << volume[4];
1287             if (volume[3]<10) ftxt << "  " << volume[3];
1288             else              ftxt << " " << volume[3];
1289             ftxt << "   " << -1;
1290             if (word<10)                           ftxt << "        " << word;
1291             else if (word>=10     && word<100)     ftxt << "       " << word;
1292             else if (word>=100    && word<1000)    ftxt << "      " << word;
1293             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1294             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1295             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1296             else                                   ftxt << "  " << word;
1297             ftxt << "   " << dummyPS << endl;
1298           }
1299
1300           AliBitPacking::PackWord(word,baseWord, 0,20);
1301           word = iCH; // TDC channel ID [0;7]
1302           AliBitPacking::PackWord(word,baseWord,21,23);
1303           word = nTDC; // TDC ID [0;14]
1304           AliBitPacking::PackWord(word,baseWord,24,27);
1305           word = 0; // error flag
1306           AliBitPacking::PackWord(word,baseWord,28,28);
1307           word = dummyPS; // Packing Status [0;3]
1308           AliBitPacking::PackWord(word,baseWord,29,30);
1309           word = 1; // TRM TDC digit ID
1310           AliBitPacking::PackWord(word,baseWord,31,31);
1311
1312           localIndex++; fWordsPerTRM++;
1313           localBuffer[localIndex]=baseWord;
1314           psArray[localIndex]=dummyPS;
1315
1316           baseWord=0;
1317
1318         } // if ( fFakeOrphaneProduction && percentFilledCells<0.12 && gRandom->Rndm()<(0.12-percentFilledCells) )
1319
1320
1321         } // if (fPackedAcquisition)
1322         else { // if (!fPackedAcquisition)
1323
1324         if ( fFakeOrphaneProduction &&
1325              percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && outOut ) {
1326
1327           percentFilledCells+=kOneMoreFilledCell;
1328
1329           trailingSpurious = Int_t(2097152*gRandom->Rndm());
1330           word = trailingSpurious;
1331           Int_t dummyPS = 2;
1332
1333           if (fVerbose==2) {
1334             if (nDDL<10) ftxt << "  " << nDDL;
1335             else         ftxt << " " << nDDL;
1336             if (nTRM<10) ftxt << "  " << nTRM;
1337             else         ftxt << " " << nTRM;
1338             ftxt << "  " << iChain;
1339             if (nTDC<10) ftxt << "  " << nTDC;
1340             else         ftxt << " " << nTDC;
1341             ftxt << "  " << iCH;
1342             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1343             else              ftxt  << "  -> " << volume[0];
1344             ftxt << "  " << volume[1];
1345             if (volume[2]<10) ftxt << "  " << volume[2];
1346             else              ftxt << " " << volume[2];
1347             ftxt << "  " << volume[4];
1348             if (volume[3]<10) ftxt << "  " << volume[3];
1349             else              ftxt << " " << volume[3];
1350             ftxt << "   " << -1;
1351             if (word<10)                           ftxt << "        " << word;
1352             else if (word>=10     && word<100)     ftxt << "       " << word;
1353             else if (word>=100    && word<1000)    ftxt << "      " << word;
1354             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1355             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1356             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1357             else                                   ftxt << "  " << word;
1358             ftxt << "   " << dummyPS << endl;
1359           }
1360
1361           AliBitPacking::PackWord(word,baseWord, 0,20);
1362           word = iCH; // TDC channel ID [0;7]
1363           AliBitPacking::PackWord(word,baseWord,21,23);
1364           word = nTDC; // TDC ID [0;14]
1365           AliBitPacking::PackWord(word,baseWord,24,27);
1366           word = 0; // error flag
1367           AliBitPacking::PackWord(word,baseWord,28,28);
1368           word = dummyPS; // Packing Status [0;3]
1369           AliBitPacking::PackWord(word,baseWord,29,30);
1370           word = 1; // TRM TDC digit ID
1371           AliBitPacking::PackWord(word,baseWord,31,31);
1372
1373           localIndex++; fWordsPerTRM++;
1374           localBuffer[localIndex]=baseWord;
1375           psArray[localIndex]=dummyPS;
1376
1377           baseWord=0;
1378
1379         } // if ( fFakeOrphaneProduction && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells)  && outOut )
1380
1381
1382         word = (timeOfFlight + Int_t(totCharge*AliTOFGeometry::ToTBinWidth()/AliTOFGeometry::TdcBinWidth()))%2097152; // trailing edge measurement
1383
1384         if (fVerbose==2) {
1385           if (nDDL<10) ftxt << "  " << nDDL;
1386           else         ftxt << " " << nDDL;
1387           if (nTRM<10) ftxt << "  " << nTRM;
1388           else         ftxt << " " << nTRM;
1389           ftxt << "  " << iChain;
1390           if (nTDC<10) ftxt << "  " << nTDC;
1391           else         ftxt << " " << nTDC;
1392           ftxt << "  " << iCH;
1393           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1394           else              ftxt  << "  -> " << volume[0];
1395           ftxt << "  " << volume[1];
1396           if (volume[2]<10) ftxt << "  " << volume[2];
1397           else              ftxt << " " << volume[2];
1398           ftxt << "  " << volume[4];
1399           if (volume[3]<10) ftxt << "  " << volume[3];
1400           else              ftxt << " " << volume[3];
1401           ftxt << "   " << -1;
1402           if (word<10)                           ftxt << "        " << word;
1403           else if (word>=10     && word<100)     ftxt << "       " << word;
1404           else if (word>=100    && word<1000)    ftxt << "      " << word;
1405           else if (word>=1000   && word<10000)   ftxt << "     " << word;
1406           else if (word>=10000  && word<100000)  ftxt << "    " << word;
1407           else if (word>=100000 && word<1000000) ftxt << "   " << word;
1408           else                                   ftxt << "  " << word;
1409           ftxt << "   " << 2 << endl;
1410         }
1411
1412         AliBitPacking::PackWord(word,baseWord, 0,20);
1413
1414         word = iCH; // TDC channel ID [0;7]
1415         AliBitPacking::PackWord(word,baseWord,21,23);
1416         word = nTDC; // TDC ID [0;14]
1417         AliBitPacking::PackWord(word,baseWord,24,27);
1418         word = 0; // error flag
1419         AliBitPacking::PackWord(word,baseWord,28,28);
1420         word = 2; // Packing Status [0;3]
1421         AliBitPacking::PackWord(word,baseWord,29,30);
1422         word = 1; // TRM TDC digit ID
1423         AliBitPacking::PackWord(word,baseWord,31,31);
1424
1425         localIndex++; fWordsPerTRM++;
1426         localBuffer[localIndex]=baseWord;
1427         psArray[localIndex]=2;
1428
1429         baseWord=0;
1430
1431         word = timeOfFlight%2097152; // leading edge measurement
1432
1433         if (fVerbose==2) {
1434           if (nDDL<10) ftxt << "  " << nDDL;
1435           else         ftxt << " " << nDDL;
1436           if (nTRM<10) ftxt << "  " << nTRM;
1437           else         ftxt << " " << nTRM;
1438           ftxt << "  " << iChain;
1439           if (nTDC<10) ftxt << "  " << nTDC;
1440           else         ftxt << " " << nTDC;
1441           ftxt << "  " << iCH;
1442           if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1443           else              ftxt  << "  -> " << volume[0];
1444           ftxt << "  " << volume[1];
1445           if (volume[2]<10) ftxt << "  " << volume[2];
1446           else              ftxt << " " << volume[2];
1447           ftxt << "  " << volume[4];
1448           if (volume[3]<10) ftxt << "  " << volume[3];
1449           else              ftxt << " " << volume[3];
1450           ftxt << "   " << -1;
1451           if (word<10)                           ftxt << "        " << word;
1452           else if (word>=10     && word<100)     ftxt << "       " << word;
1453           else if (word>=100    && word<1000)    ftxt << "      " << word;
1454           else if (word>=1000   && word<10000)   ftxt << "     " << word;
1455           else if (word>=10000  && word<100000)  ftxt << "    " << word;
1456           else if (word>=100000 && word<1000000) ftxt << "   " << word;
1457           else                                   ftxt << "  " << word;
1458           ftxt << "   " << 1 << endl;
1459         }
1460
1461         AliBitPacking::PackWord(word,baseWord, 0,20);
1462
1463         word = iCH; // TDC channel ID [0;7]
1464         AliBitPacking::PackWord(word,baseWord,21,23);
1465         word = nTDC; // TDC ID [0;14]
1466         AliBitPacking::PackWord(word,baseWord,24,27);
1467         word = 0; // error flag
1468         AliBitPacking::PackWord(word,baseWord,28,28);
1469         word = 1; // Packing Status [0;3]
1470         AliBitPacking::PackWord(word,baseWord,29,30);
1471         word = 1; // TRM TDC digit ID
1472         AliBitPacking::PackWord(word,baseWord,31,31);
1473
1474         localIndex++; fWordsPerTRM++;
1475         localBuffer[localIndex]=baseWord;
1476         psArray[localIndex]=1;
1477
1478         baseWord=0;
1479
1480
1481         if ( fFakeOrphaneProduction &&
1482              percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && !outOut ) {
1483
1484           percentFilledCells+=kOneMoreFilledCell;
1485
1486           leadingSpurious = Int_t(2097152*gRandom->Rndm());
1487           word = leadingSpurious;
1488           Int_t dummyPS = 1;
1489
1490           if (fVerbose==2) {
1491             if (nDDL<10) ftxt << "  " << nDDL;
1492             else         ftxt << " " << nDDL;
1493             if (nTRM<10) ftxt << "  " << nTRM;
1494             else         ftxt << " " << nTRM;
1495             ftxt << "  " << iChain;
1496             if (nTDC<10) ftxt << "  " << nTDC;
1497             else         ftxt << " " << nTDC;
1498             ftxt << "  " << iCH;
1499             if (volume[0]<10) ftxt  << "  ->  " << volume[0];
1500             else              ftxt  << "  -> " << volume[0];
1501             ftxt << "  " << volume[1];
1502             if (volume[2]<10) ftxt << "  " << volume[2];
1503             else              ftxt << " " << volume[2];
1504             ftxt << "  " << volume[4];
1505             if (volume[3]<10) ftxt << "  " << volume[3];
1506             else              ftxt << " " << volume[3];
1507             ftxt << "   " << -1;
1508             if (word<10)                           ftxt << "        " << word;
1509             else if (word>=10     && word<100)     ftxt << "       " << word;
1510             else if (word>=100    && word<1000)    ftxt << "      " << word;
1511             else if (word>=1000   && word<10000)   ftxt << "     " << word;
1512             else if (word>=10000  && word<100000)  ftxt << "    " << word;
1513             else if (word>=100000 && word<1000000) ftxt << "   " << word;
1514             else                                   ftxt << "  " << word;
1515             ftxt << "   " << dummyPS << endl;
1516           }
1517
1518           AliBitPacking::PackWord(word,baseWord, 0,20);
1519           word = iCH; // TDC channel ID [0;7]
1520           AliBitPacking::PackWord(word,baseWord,21,23);
1521           word = nTDC; // TDC ID [0;14]
1522           AliBitPacking::PackWord(word,baseWord,24,27);
1523           word = 0; // error flag
1524           AliBitPacking::PackWord(word,baseWord,28,28);
1525           word = dummyPS; // Packing Status [0;3]
1526           AliBitPacking::PackWord(word,baseWord,29,30);
1527           word = 1; // TRM TDC digit ID
1528           AliBitPacking::PackWord(word,baseWord,31,31);
1529
1530           localIndex++; fWordsPerTRM++;
1531           localBuffer[localIndex]=baseWord;
1532           psArray[localIndex]=dummyPS;
1533
1534           baseWord=0;
1535
1536         } // if ( fFakeOrphaneProduction && percentFilledCells<0.24 && gRandom->Rndm()<(0.24-percentFilledCells) && !outOut )
1537
1538
1539         } // if (!fPackedAcquisition)
1540
1541       } //end loop on digits in the same volume
1542
1543       //if (numberOfMeasuresPerChannel>maxMeasuresPerChannelInTDC)
1544       //maxMeasuresPerChannelInTDC = numberOfMeasuresPerChannel;
1545
1546     } // end loop on TDC channel number
1547
1548     //AliDebug(3,Form(" TDC number %2i:  numberOfMeasuresPerChannel = %2i  ---  maxMeasuresPerChannelInTDC = %2i ", nTDC, numberOfMeasuresPerChannel, maxMeasuresPerChannelInTDC));
1549
1550     if (localIndex==-1) continue;
1551
1552     if (fPackedAcquisition) {
1553
1554       for (jj=0; jj<=localIndex; jj++) {
1555         fIndex++;
1556         buf[fIndex] = localBuffer[jj];
1557         localBuffer[jj] = 0;
1558         psArray[jj] = -1;
1559       }
1560
1561     }
1562     else {
1563       /*
1564       if (maxMeasuresPerChannelInTDC = 1) {
1565
1566         for (Int_t jj=0; jj<=localIndex; jj++) {
1567           if (psArray[jj]==2) {
1568             fIndex++;
1569             buf[fIndex] = localBuffer[jj];
1570             localBuffer[jj] = 0;
1571             psArray[jj] = -1;
1572           }
1573         }
1574         for (Int_t jj=0; jj<=localIndex; jj++) {
1575           if (psArray[jj]==1) {
1576             fIndex++;
1577             buf[fIndex] = localBuffer[jj];
1578             localBuffer[jj] = 0;
1579             psArray[jj] = -1;
1580           }
1581         }
1582
1583       } // if (maxMeasuresPerChannelInTDC = 1)
1584       else if (maxMeasuresPerChannelInTDC>1) {
1585
1586         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",
1587                      nDDL, nTRM, iChain, nTDC, iCH, maxMeasuresPerChannelInTDC));
1588       */
1589       for (jj=0; jj<=localIndex; jj++) {
1590             fIndex++;
1591             buf[fIndex] = localBuffer[jj];
1592             localBuffer[jj] = 0;
1593             psArray[jj] = -1;
1594         }
1595
1596         //} // else if (maxMeasuresPerChannelInTDC>1)
1597
1598     } // else (!fPackedAcquisition)
1599
1600     localIndex = -1;
1601
1602     //maxMeasuresPerChannelInTDC = 0;
1603
1604   } // end loop on TDC number
1605
1606
1607   if (fVerbose==2) ftxt.close();
1608
1609 }
1610
1611 //----------------------------------------------------------------------------
1612 void AliTOFDDLRawData::ReverseArray(UInt_t a[], Int_t n) const
1613 {
1614   //
1615   // Reverses the n elements of array a
1616   //
1617
1618   Int_t ii, temp;
1619
1620   for (ii=0; ii<n/2; ii++) {
1621     temp      = a[ii];
1622     a[ii]     = a[n-ii-1];
1623     a[n-ii-1] = temp;
1624   }
1625
1626   return;
1627
1628 }
1629
1630 //----------------------------------------------------------------------------
1631 Bool_t AliTOFDDLRawData::HeadOrTail() const
1632 {
1633   //
1634   // Returns the result of a 'pitch and toss'
1635   //
1636
1637   Double_t dummy = gRandom->Rndm();
1638
1639   if (dummy<0.5) return kFALSE;
1640   else return kTRUE;
1641
1642 }