TRD/AliTRDptrgFEB.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 //  This class is used to simulate the front end box behavior of the
  25 //  pretrigger system. Digits of T0 and V0 are used as input. A threshold
  26 //  discrimination, masking and first processing with look up tables  is
  27 //  done during the simulation process
  28 //
  29 ////////////////////////////////////////////////////////////////////////////
  30
  31 #include <TClonesArray.h>
  32
  33 #include "AliRunLoader.h"
  34 #include "AliLog.h"
  35
  36 #include "../VZERO/AliVZEROdigit.h"
  37 #include "../T0/AliT0digit.h"
  38
  39 #include "AliTRDptrgParam.h"
  40 #include "AliTRDptrgLUT.h"
  41 #include "AliTRDptrgFEB.h"
  42
  43 ClassImp(AliTRDptrgFEB)
  44
  45 //______________________________________________________________________________
  46 AliTRDptrgFEB::AliTRDptrgFEB(AliRunLoader *rl)
  47   : TObject(),
  48   fRunLoader(rl),
  49   fParam(0),
  50   fLUTArray(0),
  51   fType(kUndefined),
  52   fOperatingMode(kDigits),
  53   fInputChannelCount(0),
  54   fPosition(kUnknown),
  55   fID(0),
  56   fThreshold(0)
  57 {
  58   // default constructor
  59   AliError("default ctor - not recommended");
  60 }
  61
  62 //______________________________________________________________________________
  63 AliTRDptrgFEB::AliTRDptrgFEB(AliRunLoader *rl, AliTRDptrgFEBType_t febType,
  64                              AliTRDptrgOperatingMode_t operatingMode,
  65                              AliTRDptrgFEBPosition_t position, Int_t id,
  66                              AliTRDptrgParam *param)
  67   : TObject(),
  68   fRunLoader(rl),
  69   fParam(param),
  70   fLUTArray(0),
  71   fType(febType),
  72   fOperatingMode(operatingMode),
  73   fInputChannelCount(0),
  74   fPosition(position),
  75   fID(id),
  76   fThreshold(0x0)
  77 {
  78   // prefered constructor
  79
  80   this->LoadParams(); // load configuration parameters
  81
  82 }
  83
  84 //______________________________________________________________________________
  85 AliTRDptrgFEB::~AliTRDptrgFEB()
  86 {
  87   // destructor
  88   if (this->fParam == 0x0) {
  89     if (this->fThreshold != 0x0) {
  90       delete[] this->fThreshold;
  91       this->fThreshold = 0x0;
  92    }
  93   }
  94   // delete LUTArray
  95   this->fLUTArray.Delete();
  96 }
  97
  98 //______________________________________________________________________________
  99 Int_t AliTRDptrgFEB::LoadDigits()
 100 {
 101   // loads T0 or V0 digits and discriminates them automatically
 102
 103   if (this->fType == kVZERO) {
 104     // load V0's digits --------------------------------------------------------
 105
 106     // get V0 run loader
 107     AliLoader* loader = this->fRunLoader->GetLoader( "VZEROLoader" );
 108
 109     if (!loader) {
 110       AliError("Can not get VZERO loader");
 111       return -1;
 112     }
 113     loader->LoadDigits("READ");
 114     TTree* vzeroDigitsTree = loader->TreeD();
 115
 116     if (!vzeroDigitsTree) {
 117       AliError("Can not get the VZERO digit tree");
 118       return -1;
 119     }
 120
 121
 122     TClonesArray* vzeroDigits = NULL;
 123     TBranch* digitBranch = vzeroDigitsTree->GetBranch("VZERODigit");
 124     digitBranch->SetAddress(&vzeroDigits);
 125     vzeroDigitsTree->GetEvent(0);
 126
 127
 128     Int_t nDigits = vzeroDigits->GetEntriesFast(); // get digit count
 129
 130     AliDebug(5, Form("Found a whole of %d digits", nDigits));
 131
 132     Int_t inputVector = 0x0; // Vector which is feed into the LUT
 133
 134     for (Int_t iDigit=0; iDigit<nDigits; iDigit++) {
 135       // loop over all digits
 136       AliDebug(5, "Looping over digit");
 137       AliVZEROdigit* digit = (AliVZEROdigit*)vzeroDigits->At(iDigit);
 138
 139       Int_t pmNumber   = digit->PMNumber();
 140       Int_t board   = pmNumber / 8;
 141       Int_t channel = pmNumber % 8;
 142       Int_t position = pmNumber / 32 + 1;
 143
 144       // check whether the digits belongs to the current FEB, otherwise omit it
 145       if ((position == this->fPosition) && (board == this->fID)) {
 146         AliDebug(5, "Found an digit corresponding to the current FEB");
 147         Float_t value = digit->ADC();
 148         AliDebug(5, Form("ADC value: %f\n", value));
 149         Int_t channelBitMask = 0x01;
 150         // channel0 => 0x01; channel1=> 0x02;  2^(channel number)
 151         channelBitMask <<= channel;
 152         if (value >= this->fThreshold[channel]) {
 153           inputVector |= channelBitMask;
 154           AliDebug(5,
 155             Form("Threshold exceeded in channel %d, new inputVector 0x%x",
 156                  channel, inputVector));
 157         }
 158       }
 159     }
 160
 161     AliDebug(5, Form("inputVector: 0x%x", inputVector));
 162
 163     return inputVector;
 164   }
 165   else if (this->fType == kTZERO) {
 166     // load T0's digits --------------------------------------------------------
 167     AliLoader * fT0Loader = this->fRunLoader->GetLoader("T0Loader");
 168     //   AliT0digit *fDigits;
 169     fT0Loader->LoadDigits("READ");
 170     // Creating T0 data container
 171
 172     TTree* treeD = fT0Loader->TreeD();
 173     if (!treeD) {
 174       AliError("no digits tree");
 175       return -1;
 176     }
 177     AliT0digit* digits = new AliT0digit();
 178     TBranch *brDigits = treeD->GetBranch("T0");
 179
 180     if (brDigits) {
 181       brDigits->SetAddress(&digits);
 182     }
 183     else {
 184       AliError("Branch T0 DIGIT not found");
 185       return -1;
 186     }
 187     brDigits->GetEntry(0);
 188
 189     TArrayI qtc0(24); // Array must have 24 entries!
 190     TArrayI qtc1(24); // Array must have 24 entries!
 191
 192     digits->GetQT0(qtc0); // baseline (reference level)
 193     digits->GetQT1(qtc1); // measurement value
 194
 195     Int_t inputVector = 0x0; // vector to be fed into the look up table
 196
 197     // PMT Positions
 198     // C: 0  to 11
 199     // A: 12 to 23
 200     // positions according to AliT0Digitizer.cxx Revision 37491
 201     Int_t nStart = 0;
 202     if (this->fPosition == kC) { // C
 203       nStart = 0;
 204     }
 205     else if (this->fPosition == kA) { // A
 206       nStart = 12;
 207     }
 208
 209     Int_t channelBitMask = 0x01;
 210     for (Int_t i = 0 + nStart; i < nStart + 12; i++) {
 211       //Int_t channelBitMask = 0x01;
 212       AliDebug(5, Form("channel: %d", i));
 213
 214       Int_t value = qtc1[i] - qtc0[i]; // calculate correct measurement value
 215
 216       if (value > (Int_t)this->fThreshold[i - nStart]) {
 217         inputVector |= channelBitMask;    // Add bit
 218
 219         AliDebug(5, Form("Threshold exceeded in channel %d,", i));
 220         AliDebug(5, Form("new inputVector 0x%x", inputVector));
 221         AliDebug(5, Form("channelBitMask 0x%x", channelBitMask));
 222       }
 223       channelBitMask <<= 1; // go on to the next channel
 224     }
 225
 226     delete digits;
 227     return inputVector;
 228   }
 229   return -1;
 230 }
 231
 232 //______________________________________________________________________________
 233 Int_t AliTRDptrgFEB::LoadAndProcessHits()
 234 {
 235   // loads TO or VO hits and converts them to digits optimized for ptrg
 236   // afterwards the digits will be discriminated
 237   AliError("LoadAndProcessHits() - not yet implemented!\n");
 238   if (this->fType == kVZERO) {
 239     return 0;
 240   }
 241   else if (this->fType == kTZERO) {
 242     return 0;
 243   }
 244   return -1;
 245 }
 246
 247 //______________________________________________________________________________
 248 Bool_t AliTRDptrgFEB::LoadParams()
 249 {
 250   // Load Parameters
 251
 252   if (this->fParam == 0x0) {
 253     AliWarning("No paramater object specified - start loading defaults\n");
 254     if (this->fType == kVZERO) {
 255       // initialize threshold
 256       this->fThreshold = new UInt_t[8];
 257       for (Int_t i = 0; i < 8; i++) {
 258         this->fThreshold[i] = 10;
 259       }
 260       // initialize LUTsoutputWidth=<value optimized out>
 261       AliTRDptrgLUT* lut = new AliTRDptrgLUT();
 262       this->fLUTArray.AddLast(lut);
 263       lut = new AliTRDptrgLUT();
 264       this->fLUTArray.AddLast(lut);
 265                         // the following lines are only needed for test reasons
 266       lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0));
 267       Int_t* initData = new Int_t[256]; // 2^8
 268       for (Int_t i = 0; i < 256; i++ ) {
 269         initData[i] = i;
 270       }
 271       lut->InitTable(8, 8, initData, kTRUE); // make copy of initData
 272       lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(1));
 273       for (Int_t i = 255; i >= 0; i--) {
 274         initData[255 - i] = i;  // inverse ramp
 275       }
 276       lut->InitTable(8, 8, initData, kTRUE);
 277     }
 278     else {
 279       // initialize threshold
 280       this->fThreshold = new UInt_t[12];
 281       for (Int_t i = 0; i < 12; i++) {
 282         this->fThreshold[i] = 10;
 283       }
 284
 285       // initialize LUTsoutputWidth=<value optimized out>
 286       AliTRDptrgLUT* lut = new AliTRDptrgLUT();
 287       this->fLUTArray.AddLast(lut);
 288       lut = new AliTRDptrgLUT(); // this->fRunLoader
 289       this->fLUTArray.AddLast(lut);
 290       // the following lines are only needed for test reasons
 291       lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0));
 292       Int_t* initData = new Int_t[4096]; // 2^12
 293       for (Int_t i = 0; i < 4096; i++ ) {
 294         initData[i] = i;
 295       }
 296       lut->InitTable(12, 12, initData, kTRUE); // make a copy of the table
 297       lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(1));
 298       for (Int_t i = 4095; i >= 0; i--) {
 299         initData[4096 - i] = i;  // inverse ramp
 300       }
 301       lut->InitTable(12, 12, initData, kTRUE); // make a copy of the table
 302       delete[] initData;
 303     }
 304     return false;
 305   }
 306   else {
 307     // load parameters from object
 308     if (this->fType == kVZERO) {
 309       // threshold
 310       this->fThreshold =
 311         this->fParam->GetFEBV0Thresholds(this->fPosition, (this->fID - 1));
 312
 313       // look up tables
 314       // 1
 315       AliTRDptrgLUT* LUT = new AliTRDptrgLUT();
 316       LUT->InitTable(8, 8, this->fParam->GetFEBV0LUT(this->fPosition,
 317                                                      (this->fID - 1),
 318                                                      0), kFALSE);
 319       // do not make a copy of the table due to performance reasons
 320       this->fLUTArray.AddLast(LUT);
 321
 322       // 2
 323       LUT = new AliTRDptrgLUT();
 324       LUT->InitTable(8, 8, this->fParam->GetFEBV0LUT(this->fPosition,
 325                                                      (this->fID - 1),
 326                                                      1), kFALSE);
 327       // do not make a copy of the table due to performance reasons
 328       this->fLUTArray.AddLast(LUT);
 329     }
 330     else {
 331       // threshold
 332       this->fThreshold =
 333         this->fParam->GetFEBT0Thresholds(this->fPosition);
 334
 335       // look up tables
 336       // 1
 337       AliTRDptrgLUT* LUT = new AliTRDptrgLUT();
 338       LUT->InitTable(12, 12, fParam->GetFEBT0LUT(this->fPosition, 0), kFALSE);
 339       // do not make a copy of the table due to performance reasosn
 340       this->fLUTArray.AddLast(LUT);
 341
 342       // 2
 343       LUT = new AliTRDptrgLUT();
 344       LUT->InitTable(12, 12, fParam->GetFEBT0LUT(this->fPosition, 1), kFALSE);
 345       // do not make a copy of the table due to performance reasosn
 346       this->fLUTArray.AddLast(LUT);
 347     }
 348     return true;
 349   }
 350
 351   return false;
 352 }
 353
 354 //______________________________________________________________________________
 355 Int_t* AliTRDptrgFEB::Simulate()
 356 {
 357   // simulates the FEB behavior and returns a 2 bit ouput
 358   // (least significant bits)
 359
 360   Int_t *result = new Int_t;
 361   (*result) = -1;
 362   if (this->fOperatingMode == kDigits) {
 363     Int_t inputVector = this->LoadDigits();
 364     delete result; // delete error return value
 365
 366     // perform look up
 367     Int_t nLUTs = this->fLUTArray.GetEntriesFast();  // get LUT count
 368     result = new Int_t[nLUTs + 1]; // generate new return array
 369     result[0] = nLUTs; // storage array length in the first array value
 370     for (Int_t iLUT = 0; iLUT < nLUTs; iLUT++) {
 371       // process the return value for each LUT and store the result in the array
 372       AliDebug(4, Form("FEB: (pos=%d,id=%d,lut=%d,vector=0x%x)",
 373                        this->fPosition, this->fID, iLUT, inputVector));
 374
 375       result[iLUT + 1] =
 376        dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray[iLUT])->LookUp(inputVector);
 377       AliDebug(4, Form("FEB result[%d] = 0x%x",(iLUT + 1),result[iLUT + 1]));
 378     }
 379   }
 380   else if (this->fOperatingMode == kHits) {
 381     return result;
 382   }
 383   return result;
 384 }