TRD/AliTRDptrgCBB.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 Control-Box bottom class                                  //
  21 //                                                                        //
  22 //  Authors: F. Reidt (Felix.Reidt@cern.ch)                               //
  23 //                                                                        //
  24 ////////////////////////////////////////////////////////////////////////////
  25
  26
  27 #include "TROOT.h"
  28
  29 #include "AliRun.h"
  30 #include "AliRunLoader.h"
  31
  32 #include "AliTRDptrgLUT.h"
  33 #include "AliTRDptrgParam.h"
  34 #include "AliTRDptrgCBAC.h"
  35 #include "AliTRDptrgTLMU.h"
  36 #include "AliTRDptrgCBB.h"
  37 ClassImp(AliTRDptrgCBB)
  38
  39 AliTRDptrgCBB::AliTRDptrgCBB(AliRunLoader *rl)
  40   : TObject(),
  41   fRunLoader(rl),
  42   fParam(0),
  43   fOperatingMode(kDigits),
  44   fCBA(0),
  45   fCBC(0),
  46   fTLMU(0),
  47   fLUTArray(0),
  48   fPTmasks(0x0)
  49 {
  50   // default ctor
  51   AliError("default ctor - usage not recommended\n");
  52 }
  53
  54
  55 AliTRDptrgCBB::AliTRDptrgCBB(AliRunLoader *rl, AliTRDptrgParam* param,
  56                              AliTRDptrgOperatingMode_t operatingMode)
  57   : TObject(),
  58   fRunLoader(rl),
  59   fParam(param),
  60   fOperatingMode(operatingMode),
  61   fCBA(0),
  62   fCBC(0),
  63   fTLMU(0),
  64   fLUTArray(0),
  65   fPTmasks(0x0)
  66 {
  67   // recommended ctor
  68   this->fCBA = new AliTRDptrgCBAC(rl, kA, operatingMode, param);
  69   this->fCBC = new AliTRDptrgCBAC(rl, kC, operatingMode, param);
  70   this->fTLMU = new AliTRDptrgTLMU(rl, param, operatingMode);
  71
  72   this->LoadParams();
  73 }
  74
  75 AliTRDptrgCBB::~AliTRDptrgCBB()
  76 {
  77   // destructor
  78
  79   if (this->fCBA != 0x0) {
  80     delete this->fCBA;
  81     this->fCBA = 0x0;
  82   }
  83
  84   if (this->fCBC != 0x0) {
  85     delete this->fCBC;
  86     this->fCBC = 0x0;
  87   }
  88
  89   if (this->fTLMU != 0x0) {
  90     delete this->fTLMU;
  91     this->fTLMU = 0x0;
  92   }
  93
  94   this->fLUTArray.Delete();
  95 }
  96
  97
  98 //______________________________________________________________________________
  99 Bool_t AliTRDptrgCBB::LoadParams()
 100 {
 101   // load configuration parameters
 102
 103   if (this->fParam != 0x0) {
 104     // read AliTRDptrgParam
 105
 106     // get LUTs
 107     // 0
 108     AliTRDptrgLUT* LUT = new AliTRDptrgLUT();
 109     LUT->InitTable(12, 12, this->fParam->GetCBLUT(0, 0), kFALSE);
 110     // get CB-B_0 and do not copy lut content
 111     this->fLUTArray.AddLast(LUT);
 112
 113     // 1
 114     LUT = new AliTRDptrgLUT();
 115     LUT->InitTable(12, 12, this->fParam->GetCBLUT(0, 1), kFALSE);
 116     // get CB-B_1 and do not copy lut content
 117     this->fLUTArray.AddLast(LUT);
 118
 119     // 2
 120     LUT = new AliTRDptrgLUT();
 121     LUT->InitTable(12, 12, this->fParam->GetCBLUT(0, 2), kFALSE);
 122     // get CB-B_2 and do not copy lut content
 123     this->fLUTArray.AddLast(LUT);
 124
 125     // masks
 126     this->fPTmasks = this->fParam->GetPTmasks();
 127   }
 128   else {
 129     // load default parameters
 130     // initialize LUTsoutputWidth=<value optimized out>
 131     AliTRDptrgLUT* lut = new AliTRDptrgLUT();
 132     this->fLUTArray.AddLast(lut);
 133     lut = new AliTRDptrgLUT(); // this->fRunLoader
 134     this->fLUTArray.AddLast(lut);
 135     lut = new AliTRDptrgLUT(); // this->fRunLoader
 136     this->fLUTArray.AddLast(lut);
 137     // the following lines are only needed for test reasons
 138     Int_t* initData = new Int_t[4096]; // 2^12
 139     lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0));
 140     if (lut) {
 141       for (Int_t i = 0; i < 4096; i++ ) {
 142         initData[i] = i;
 143       }
 144       lut->InitTable(12, 12, initData, kTRUE); // make a copy
 145     }
 146     lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0));
 147     if (lut) {
 148       for (Int_t i = 0; i < 4096; i++ ) {
 149         initData[i] = i;
 150       }
 151       lut->InitTable(12, 12, initData, kTRUE); // make a copy
 152     }
 153     lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(1));
 154     if (lut) {
 155       //for (Int_t i = 4096; i >= 0; i--) {
 156       for (Int_t i = 4096; i > 0; i--) {
 157         initData[4096 - i] = i;  // inverse ramp
 158       }
 159       lut->InitTable(12, 12, initData, kTRUE); // make a copy
 160     }
 161     delete [] initData;
 162
 163     AliTRDptrgParam::AliTRDptrgPTmasks* masks =
 164       new AliTRDptrgParam::AliTRDptrgPTmasks();
 165     masks->fLUTs[0] = kTRUE;
 166     masks->fLUTs[1] = kTRUE;
 167     masks->fLUTs[2] = kTRUE;
 168     this->fPTmasks = masks;
 169   }
 170   return false;
 171 }
 172
 173 //______________________________________________________________________________
 174 Int_t* AliTRDptrgCBB::Simulate()
 175 {
 176   // Simulate the CBB behavior of event
 177   //
 178   // returns array containing:
 179   // 0: array element count
 180   // 1..count-2: LUT results
 181   // count-1: pretrigger decision
 182
 183   Int_t nLUTs = this->fLUTArray.GetEntries();
 184
 185   Int_t inputVector = 0x0;
 186   // initialize partResults
 187   Int_t** partResults = 0x0;
 188   partResults = new Int_t* [3]; // CB-A, CB-C, TLMU
 189
 190   // get partResults
 191   partResults[0] = this->fCBA->Simulate(); // CB-A
 192   partResults[1] = this->fCBC->Simulate(); // CB-C
 193   partResults[2] = this->fTLMU->Simulate(); // TLMU
 194
 195   // combine partResults and create inputVectors
 196   Int_t mask = 0x1;
 197   for (Int_t i = 0; i < 3 ; i++) {
 198     for (Int_t j = 1; j <= partResults[i][0]; j++) {
 199       if (partResults[i][j] > 0) {
 200         inputVector |= mask; // Add bit to the  inputVector
 201       }
 202       mask <<= 1;
 203     }
 204   }
 205
 206   AliDebug(5, Form("Inputvectors: 0x%x", inputVector));
 207
 208   // perform look up
 209   Int_t* result = new Int_t[nLUTs + 2]; // generate new return array
 210   result[0] = nLUTs + 1; // storage array length in the first array value
 211   for (Int_t iLUT = 0; iLUT < nLUTs; iLUT++) {
 212     // process the return value for each LUT and store the result in the array
 213     AliTRDptrgLUT *lutTmp = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray[iLUT]);
 214     if (lutTmp) {
 215       result[iLUT + 1] = lutTmp->LookUp(inputVector);
 216     }
 217     AliDebug(4, Form("CBB result[%d] = 0x%x\n",(iLUT + 1),result[iLUT + 1]));
 218   }
 219
 220   // evaluate PT decision
 221   // stored in result[nLUTs + 1]
 222   result[nLUTs + 1] = 0;
 223
 224   for (Int_t i = 0; i < 2; i++) {
 225     // CB-A
 226     if (this->fPTmasks->fCBA[i] && partResults[0][i + 1]) {
 227       result[nLUTs + 1]++;
 228     }
 229     // CB-C
 230     if (this->fPTmasks->fCBC[i] && partResults[1][i + 1]) {
 231       result[nLUTs + 1]++;
 232     }
 233     // CB-B (own LUTs)
 234     if (this->fPTmasks->fLUTs[i] && result[i + 1]) {
 235       result[nLUTs + 1]++;
 236     }
 237   }
 238   if (this->fPTmasks->fLUTs[2] && result[3]) { // CB-B (third own LUT)
 239     result[nLUTs + 1]++;
 240   }
 241
 242   // TLMU
 243   for (Int_t i = 0; i < 8; i++) {
 244     if (this->fPTmasks->fTLMU[i] && partResults[2][i + 1]) {
 245       result[nLUTs + 1]++;
 246     }
 247   }
 248   AliDebug(4, Form("CBB TRD Wake up result = %d", result[nLUTs + 1]));
 249
 250   delete [] partResults;
 251
 252   return result;
 253
 254 }
 255
 256 //______________________________________________________________________________
 257 Bool_t AliTRDptrgCBB::GetPT() {
 258   // evaluates the pre trigger decision
 259
 260   Int_t* LUTresults = this->Simulate();
 261   if (LUTresults[(LUTresults[0] - 1)]) {
 262     delete[] LUTresults;
 263     return kTRUE;
 264   }
 265   else {
 266     delete[] LUTresults;
 267     return kFALSE;
 268   }
 269 }