TRD/AliTRDptrgTLMU.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, 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 /* $Id$ */
  17
  18 ////////////////////////////////////////////////////////////////////////////
  19 //                                                                        //
  20 //  Pre-Trigger simulation                                                //
  21 //                                                                        //
  22 //  Authors: F. Reidt (Felix.Reidt@cern.ch)                               //
  23 //                                                                        //
  24 ////////////////////////////////////////////////////////////////////////////
  25
  26 #include "TFile.h"
  27 #include "TROOT.h"
  28
  29 #include "TClonesArray.h"
  30
  31 #include "AliRun.h"
  32 #include "AliRunLoader.h"
  33
  34 #include "../TOF/AliTOFdigit.h"
  35 #include "../RAW/AliRawReader.h" // needed for AliTOFTrigger's raw digit support
  36 #include "../TOF/AliTOFTrigger.h"
  37
  38 #include "AliTRDptrgParam.h"
  39
  40 #include "AliTRDptrgTLMU.h"
  41
  42 ClassImp(AliTRDptrgTLMU)
  43
  44 //______________________________________________________________________________
  45 AliTRDptrgTLMU::AliTRDptrgTLMU(AliRunLoader *rl)
  46   : TObject(),
  47   fRunLoader(rl),
  48   fParam(0x0),
  49   fOperatingMode(kDigits),
  50   fInputMask(0x0),
  51   fCMatrices(0x0),
  52   fMultiplicity(0x0),
  53   fOutput(0x0)
  54 {
  55   // default ctor
  56
  57   for (Int_t i = 0; i < 18; i++) {
  58     this->fTOFinputBits[i] = 0;
  59   }
  60
  61   this->LoadParams();
  62 }
  63
  64 //______________________________________________________________________________
  65 AliTRDptrgTLMU::AliTRDptrgTLMU(AliRunLoader *rl,  AliTRDptrgParam *param,
  66                                AliTRDptrgOperatingMode_t operatingMode)
  67   : TObject(),
  68   fRunLoader(rl),
  69   fParam(param),
  70   fOperatingMode(operatingMode),
  71   fInputMask(0x0),
  72   fCMatrices(0x0),
  73   fMultiplicity(0x0),
  74   fOutput(0x0)
  75 {
  76   // recommended ctor
  77
  78   for (Int_t i = 0; i < 18; i++) {
  79     this->fTOFinputBits[i] = 0;
  80   }
  81
  82   this->LoadParams();
  83 }
  84
  85 //______________________________________________________________________________
  86 AliTRDptrgTLMU::~AliTRDptrgTLMU()
  87 {
  88   // destructor
  89
  90   this->fCMatrices = 0x0;
  91   this->fMultiplicity = 0x0;
  92   this->fOutput = 0x0;
  93 }
  94
  95 //______________________________________________________________________________
  96 Int_t* AliTRDptrgTLMU::Simulate()
  97 {
  98   // starts a simulation
  99
 100   if (this->fOperatingMode == kDigits) {
 101     this->LoadDigits();
 102   }
 103   else if (this->fOperatingMode == kHits) {
 104     return 0x0; // TODO
 105   }
 106
 107   // which super modules are active? - needed for fast coincidence processing:
 108   // M(sm | coincidence condition)>=2
 109   UInt_t temp = 0x1;
 110   UInt_t sm = 0x0;
 111   for (Int_t iSM = 0; iSM < 18; iSM++) {
 112     if (this->Or(iSM)) {
 113       sm |= temp;
 114     }
 115     temp <<= 1;
 116   }
 117   AliDebug(4, Form("Active supermodules: 0x%x", sm));
 118
 119   // get multiplicity
 120   UInt_t multiplicity = this->GetMultiplicitySum();
 121   AliDebug(4, Form("TOF/TLMU multiplicity: %d", multiplicity));
 122
 123   Int_t* result = new Int_t[9];
 124   result[0] = 8;
 125   for (Int_t iResult = 0; iResult < 8; iResult++) {
 126     result[iResult + 1] = 0;
 127
 128     // coincidence matrix
 129     if (this->fOutput[iResult][0] != -1) {
 130       for (Int_t iLine = 0; iLine < 18; iLine++) {
 131         AliDebug(5, Form("Entry: %d, matrix: %d, line: %d, output: 0x%x",
 132                          iResult, this->fOutput[iResult][0], iLine, sm &
 133                          this->fCMatrices[this->fOutput[iResult][0]][iLine]));
 134         if (this->GetBitVectorMultiplicity(
 135              sm & this->fCMatrices[this->fOutput[iResult][0]][iLine]) > 1) {
 136           result[iResult + 1] = 1;
 137           break;
 138         }
 139       }
 140     }
 141
 142     // multiplicity conditions
 143     if (this->fOutput[iResult][1] != -1) {
 144       AliDebug(5, Form("Entry: %d, slice: %d", iResult,
 145                        this->fOutput[iResult][1]));
 146       if ((this->fMultiplicity[this->fOutput[iResult][1]][0] < multiplicity) &&
 147           (this->fMultiplicity[this->fOutput[iResult][1]][1] >= multiplicity)) {
 148         result[iResult + 1] = 1;
 149       }
 150     }
 151     AliDebug(4, Form("TLMU result[%d] = %d", iResult, result[iResult + 1]));
 152   }
 153
 154   return result;
 155 }
 156
 157 //______________________________________________________________________________
 158 Int_t AliTRDptrgTLMU::LoadDigits()
 159 {
 160   // loads Digits (for usage with aquired data)
 161   this->GetInputBits(); // get bits from AliTOFTrigger
 162   return 0;
 163 }
 164
 165
 166 //______________________________________________________________________________
 167 Bool_t AliTRDptrgTLMU::LoadParams()
 168 {
 169   // load AliTRDprtgParam content
 170
 171   if (this->fParam == 0x0) {
 172     // no parameter object assigned
 173     AliWarning("no parameter object assigned - using default settings!");
 174
 175     UInt_t* imask = 0x0;
 176     imask = new UInt_t[18];
 177     for (Int_t i = 0; i < 18; i++) {
 178       imask[i] = 0xFFFFFFFF;
 179     }
 180
 181     this->fInputMask = imask;
 182
 183     // TLMU Coincidence Matrices
 184     this->fCMatrices = new UInt_t*[3];
 185     this->fCMatrices[0] = new UInt_t[18];
 186     this->fCMatrices[1] = new UInt_t[18];
 187     this->fCMatrices[2] = new UInt_t[18];
 188
 189     // Matrix 0: Back-To-Back
 190     // Matrix 1: Back-To-Back +/-1
 191     // Matrix 2: Back-To-Back +/-2
 192     for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
 193       for (UInt_t iSlice = 0; iSlice < 18; iSlice++) {
 194         if (iMatrix == 0) {
 195           if (iSlice < 9) {
 196             this->fCMatrices[iMatrix][iSlice] = 0x201 << iSlice;
 197             // Back-To-Back
 198             AliDebug(5, Form("fCMatrices[%d][%d]=0x%x",iMatrix,iSlice,
 199                              this->fCMatrices[iMatrix][iSlice]));
 200           }
 201           // because of symmetrie the other slices are not necessary
 202         }
 203         else if (iMatrix == 1)  {
 204           // Back-To-Back +/- 1
 205           if (iSlice < 8) {
 206             this->fCMatrices[iMatrix][iSlice] = 0x381 << iSlice;
 207           }
 208           else if (iSlice == 8) {
 209             this->fCMatrices[iMatrix][iSlice] = 0x30101;
 210           }
 211           else if (iSlice == 9) {
 212             this->fCMatrices[iMatrix][iSlice] = 0x20203;
 213           }
 214           else {
 215             this->fCMatrices[iMatrix][iSlice] = 0x407 << (iSlice - 10);
 216           }
 217           AliDebug(5, Form("fCMatrices[%d][%d]=0x%x",iMatrix,iSlice,
 218                            this->fCMatrices[iMatrix][iSlice]));
 219         }
 220         else if (iMatrix == 2) {
 221           // Back-To-Back +/-2
 222           if (iSlice < 7 ) {
 223             this->fCMatrices[iMatrix][iSlice] = 0xF81 << iSlice;
 224           }
 225           else if (iSlice == 7) {
 226             this->fCMatrices[iMatrix][iSlice] = 0x3C081;
 227           }
 228           else if (iSlice == 8) {
 229             this->fCMatrices[iMatrix][iSlice] = 0x38103;
 230           }
 231           else if (iSlice == 9) {
 232             this->fCMatrices[iMatrix][iSlice] = 0x30207;
 233           }
 234           else if (iSlice == 10) {
 235             this->fCMatrices[iMatrix][iSlice] = 0x2040F;
 236           }
 237           else {
 238             this->fCMatrices[iMatrix][iSlice] = 0x81F << (iSlice - 11);
 239           }
 240           AliDebug(5, Form("fCMatrices[%d][%d]=0x%x",iMatrix,iSlice,
 241                            this->fCMatrices[iMatrix][iSlice]));
 242         }
 243       }
 244     }
 245
 246     // Mulitplicity
 247     this->fMultiplicity = new UInt_t*[9];
 248     for (Int_t i = 0; i < 9; i++) {
 249       this->fMultiplicity[i] = new UInt_t[2];
 250     }
 251     this->fMultiplicity[0][0] = 0;
 252     this->fMultiplicity[0][1] = 10;
 253     this->fMultiplicity[1][0] = 10;
 254     this->fMultiplicity[1][1] = 25;
 255     this->fMultiplicity[2][0] = 25;
 256     this->fMultiplicity[2][1] = 50;
 257     this->fMultiplicity[3][0] = 50;
 258     this->fMultiplicity[3][1] = 100;
 259     this->fMultiplicity[4][0] = 100;
 260     this->fMultiplicity[4][1] = 200;
 261     this->fMultiplicity[5][0] = 200;
 262     this->fMultiplicity[5][1] = 350;
 263     this->fMultiplicity[6][0] = 350;
 264     this->fMultiplicity[6][1] = 400;
 265     this->fMultiplicity[7][0] = 400;
 266     this->fMultiplicity[7][1] = 576;
 267     this->fMultiplicity[8][0] = 100;
 268     this->fMultiplicity[8][1] = 576;
 269
 270     // TLMU output
 271     this->fOutput = new Int_t*[8];
 272     for (Int_t i = 0; i < 9; i++) {
 273       this->fOutput[i] = new Int_t[2];
 274       this->fOutput[i][0] = -1;
 275       this->fOutput[i][1] = -1;
 276     }
 277     this->fOutput[0][0] = 0;
 278     this->fOutput[1][0] = 1;
 279     this->fOutput[2][0] = 2;
 280     this->fOutput[3][1] = 0;
 281     this->fOutput[4][1] = 1;
 282     this->fOutput[5][1] = 2;
 283     this->fOutput[6][1] = 3;
 284     this->fOutput[7][1] = 8;
 285
 286
 287   }
 288   else {
 289     // parameter object assigned
 290
 291     this->fInputMask = this->fParam->GetTLMUInputMask();
 292     // input mask for TOF-bits (18x32=576)
 293
 294     this->fCMatrices = this->fParam->GetTLMUcmatrices();
 295     // get coincidence matrices
 296
 297     this->fMultiplicity = this->fParam->GetTLMUmultiplicity();
 298     // get multiplicity slices
 299
 300     this->fOutput = this->fParam->GetTLMUoutput();
 301     // get output signal assignment
 302   }
 303
 304   return false;
 305 }
 306
 307 //______________________________________________________________________________
 308 void AliTRDptrgTLMU::GetInputBits() {
 309   // Gets TOF-to-TRD input bits from AliTOFTrigger as Bool_t array
 310
 311   AliTOFTrigger *toftrig = new AliTOFTrigger(); // create AliTOFTrigger
 312   toftrig->CreateLTMMatrixFromDigits(); // Generate LTMMatrix from AliTOFdigits
 313
 314   // prepare map
 315   Bool_t** map = 0x0;
 316   map = new Bool_t*[72];
 317   for (Int_t i=0; i < 72; i++)
 318     map[i] = new Bool_t[8];
 319
 320   // initialise map
 321   for (Int_t i=0; i < 72; i++)
 322     for (Int_t j=0; j < 8; j++)
 323       map[i][j] = kFALSE;
 324
 325   // get 576 TOF-to-TRD bits
 326   toftrig->GetTRDmap(map);
 327
 328   //* DEBUG output
 329   // used to determine the correct bit assignment
 330   AliDebug(5, "AliTOFTrigger->GetTRDmap(map):");
 331   for (Int_t i=0; i < 72; i++) {
 332     AliDebug(5, Form("%d %d%d%d%d%d%d%d%d", i, map[i][0], map[i][1], map[i][2],
 333                       map[i][3], map[i][4], map[i][5], map[i][6], map[i][7]));
 334   }
 335   //*/ // end of DEBUG output
 336
 337   // initialise fTOFinputBits
 338   for (Int_t i=0; i < 18; i++) {
 339     this->fTOFinputBits[i] = 0;
 340   }
 341
 342
 343   // transform Bool_t array to UInt_t bitvectors according to
 344   // http://www.physi.uni-heidelberg.de/~schicker/cbtof/cbtof_docu.pdf
 345   // chapter 1.4 and 2.1 to a supermodule based structured
 346   // integer (bit) array
 347   Int_t supermodule = -1;
 348   UInt_t tempA = 0x00000001;
 349   UInt_t tempC = 0x00010000;
 350   for (Int_t iLTM = 0; iLTM < (kNLTM / 2); iLTM++) {
 351     if (!(iLTM % 2)) { // renew temp vectors, update supermodule
 352       tempA = 0x00000001;
 353       tempC = 0x00010000;
 354       supermodule++;
 355     }
 356     // AliDebug(5, Form("(%2d,0x%8x,0x%8x)", iLTM, tempA, tempC));
 357     for (Int_t iLTMchan = 0; iLTMchan < 8; iLTMchan++) {
 358       // A-side
 359       if (map[iLTM][iLTMchan]) {
 360         this->fTOFinputBits[supermodule] |= tempA;
 361       }
 362       // C-side
 363       if (map[iLTM + 36][iLTMchan]) {
 364         this->fTOFinputBits[supermodule] |= tempC;
 365       }
 366       // change temp vectors
 367       tempA <<= 1;
 368       tempC <<= 1;
 369     }
 370   }
 371
 372   // handle input mask
 373   for (Int_t iSM = 0; iSM < 18; iSM++) {
 374     AliDebug(5, Form("fInputTOFinputBits[%d]=0x%x", iSM,
 375              this->fTOFinputBits[iSM]));
 376     this->fTOFinputBits[iSM] &= this->fInputMask[iSM];
 377   }
 378 }
 379
 380
 381 //______________________________________________________________________________
 382 Int_t AliTRDptrgTLMU::BackToBack(Int_t iSM, Int_t range) {
 383   // Check whether there is an back-to-back particle trace
 384
 385   // get the counterpart of supermodule iSM
 386   Int_t counterPart = -1;
 387   if (iSM >= 9) {
 388     counterPart = iSM - 9;
 389   }
 390   else  {
 391     counterPart = iSM + 9;
 392   }
 393
 394   if (this->Or(iSM)) { // is there are active bits in supermodule iSM
 395     Int_t result = 0;
 396     for (Int_t i = counterPart - range; i <= counterPart + range; i++) {
 397       // check whether there are active bits in supermodule i (counterParts)
 398       if ((i >= 0) && (i < 18)) {
 399         if (Or(i)) {
 400           result++;
 401         }
 402       }
 403       else {
 404         if (i < 0) {
 405           if (Or(17 - i)) {
 406             result++;
 407           }
 408         }
 409         if (i > 17) {
 410           if (Or(i - 18)) {
 411             result++;
 412           }
 413         }
 414       }
 415     }
 416     AliDebug(5, Form("BackToBack of %d and %d+-%d\n: %d", iSM, counterPart,
 417                      range, result));
 418     return result; // return whether there was a possible back-to-back trace
 419   }
 420   else {
 421     AliDebug(5, Form("BackToBack unsuccessful, not hit in sm%d", iSM));
 422     return 0; // iSM did not recognize anything
 423   }
 424 }
 425
 426 //______________________________________________________________________________
 427 Int_t AliTRDptrgTLMU::Coincidence(Int_t iSM1, Int_t iSM2) {
 428   // checks whether there is an coincidence in iSM1 and iSM2
 429
 430   if (this->Or(iSM1) && this->Or(iSM2)) {
 431     return 1;
 432   }
 433   else
 434     return 0;
 435 }
 436
 437 //______________________________________________________________________________
 438 inline Int_t AliTRDptrgTLMU::Or(Int_t  iSM) {
 439   // returns 1 if one or more bits are active in supermodule iSM
 440
 441   if ((iSM >= 0) && (iSM < 18)) {
 442     if (this->fTOFinputBits[iSM] > 0)
 443       return 1;
 444     else
 445       return 0;
 446   }
 447   else {
 448     return -1;
 449   }
 450 }
 451
 452 //______________________________________________________________________________
 453 Int_t AliTRDptrgTLMU::GetMultiplicity(Int_t iSM) {
 454   // counts how many bits equal one are in class member fTOFinputBits[iSM]
 455   // (32bits from TOF to TRD of supermodule iSM)
 456
 457   UInt_t temp = this->fTOFinputBits[iSM];
 458   UInt_t mask = 0x01;
 459   Int_t multiplicity = 0;
 460
 461   for (int iBit = 0; iBit < 32; iBit++) {
 462     if ((mask & temp) != 0x0) { // is the bit equal one?
 463       multiplicity++;
 464     }
 465     mask <<= 1; // rotate mask to the left after each iteration
 466   }
 467   AliDebug(5, Form("Multiplicity of supermodule %d: %d", iSM, multiplicity));
 468   return multiplicity;
 469 }
 470
 471 //______________________________________________________________________________
 472 Int_t AliTRDptrgTLMU::GetMultiplicitySum() {
 473   // returns the multiplicity of the whole detector (all 576bit TOF to TRD bits)
 474   Int_t sum = 0;
 475
 476   for (Int_t i = 0; i < 18; i++) {
 477     sum += this->GetMultiplicity(i);
 478   }
 479   AliDebug(5, Form("Whole multiplicity: %d", sum));
 480   return sum;
 481 }
 482
 483 //______________________________________________________________________________
 484 UInt_t AliTRDptrgTLMU::GetBitVectorMultiplicity(UInt_t BitVector) {
 485   // returns the multiplicity of a given bit vector
 486
 487   UInt_t result = 0;
 488   UInt_t temp = 0x01;
 489   for (UInt_t iBit = 0; iBit < 32; iBit++) {
 490     if (BitVector & temp) {
 491       result++;
 492     }
 493     temp <<= 1;
 494   }
 495
 496   return result;
 497 }