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