TOF/AliTOFDDLRawData.cxx

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