--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
+////////////////////////////////////////////////////////////////////////////
+//
+// Pre-Trigger simulation
+//
+// Authors: F. Reidt (Felix.Reidt@cern.ch)
+//
+// This class is used to simulate the front end box behavior of the
+// pretrigger system. Digits of T0 and V0 are used as input. A threshold
+// discrimination, masking and first processing with look up tables is
+// done during the simulation process
+//
+////////////////////////////////////////////////////////////////////////////
+
+#include <TClonesArray.h>
+#include <TTree.h>
+
+#include "AliRunLoader.h"
+#include "AliLoader.h"
+#include "AliLog.h"
+
+#include "AliVZEROdigit.h"
+#include "AliVZEROCalibData.h"
+#include "AliT0digit.h"
+
+#include "AliTRDptrgParam.h"
+#include "AliTRDptrgLUT.h"
+#include "AliTRDptrgFEB.h"
+
+ClassImp(AliTRDptrgFEB)
+
+//______________________________________________________________________________
+AliTRDptrgFEB::AliTRDptrgFEB(AliRunLoader *rl)
+ : TObject(),
+ fRunLoader(rl),
+ fParam(0),
+ fLUTArray(0),
+ fType(AliTRDptrgParam::kUndefined),
+ fOperatingMode(AliTRDptrgParam::kDigits),
+ fInputChannelCount(0),
+ fPosition(AliTRDptrgParam::kUnknown),
+ fID(0),
+ fThreshold(0)
+{
+ // default constructor
+ AliError("default ctor - not recommended");
+}
+
+//______________________________________________________________________________
+AliTRDptrgFEB::AliTRDptrgFEB(AliRunLoader *rl, AliTRDptrgParam::AliTRDptrgFEBType_t febType,
+ AliTRDptrgParam::AliTRDptrgOperatingMode_t operatingMode,
+ AliTRDptrgParam::AliTRDptrgFEBPosition_t position, Int_t id,
+ AliTRDptrgParam *param)
+ : TObject(),
+ fRunLoader(rl),
+ fParam(param),
+ fLUTArray(0),
+ fType(febType),
+ fOperatingMode(operatingMode),
+ fInputChannelCount(0),
+ fPosition(position),
+ fID(id),
+ fThreshold(0x0)
+{
+ // prefered constructor
+
+ this->LoadParams(); // load configuration parameters
+
+}
+
+//______________________________________________________________________________
+AliTRDptrgFEB::~AliTRDptrgFEB()
+{
+ // destructor
+ if (this->fParam == 0x0) {
+ if (this->fThreshold != 0x0) {
+ delete[] this->fThreshold;
+ this->fThreshold = 0x0;
+ }
+ }
+ // delete LUTArray
+ this->fLUTArray.Delete();
+}
+
+//______________________________________________________________________________
+Int_t AliTRDptrgFEB::LoadDigits()
+{
+ // loads T0 or V0 digits and discriminates them automatically
+
+ if (this->fType == AliTRDptrgParam::kVZERO) {
+ // load V0's digits --------------------------------------------------------
+ // behavior adapted for AliVZERODigitizer.cxx 40613 2010-04-22 09:57:15Z
+
+ // get V0 run loader
+ AliLoader* loader = this->fRunLoader->GetLoader( "VZEROLoader" );
+
+ if (!loader) {
+ AliError("Cannot get VZERO loader");
+ return -1;
+ }
+ loader->LoadDigits("READ");
+ TTree* vzeroDigitsTree = loader->TreeD();
+
+ if (!vzeroDigitsTree) {
+ AliError("Cannot get the VZERO digit tree");
+ return -1;
+ }
+
+
+ TClonesArray* vzeroDigits = NULL;
+ TBranch* digitBranch = vzeroDigitsTree->GetBranch("VZERODigit");
+ digitBranch->SetAddress(&vzeroDigits);
+ vzeroDigitsTree->GetEvent(0);
+
+
+ Int_t nDigits = vzeroDigits->GetEntriesFast(); // get digit count
+
+ AliDebug(5, Form("Found a whole of %d digits", nDigits));
+
+ Int_t inputVector = 0x0; // Vector which is feed into the LUT
+
+ for (Int_t iDigit=0; iDigit<nDigits; iDigit++) {
+ // loop over all digits
+ AliDebug(5, "Looping over digit");
+ AliVZEROdigit* digit = (AliVZEROdigit*)vzeroDigits->At(iDigit);
+
+ Int_t pmNumber = digit->PMNumber();
+ // Int_t board = pmNumber / 8; // changed in Version 40613
+ Int_t feeBoard = AliVZEROCalibData::GetBoardNumber(pmNumber);
+ Int_t board = feeBoard % 4; // feeBoard V0-A: 1-4; V0-C: 5-8 => board: 1-4
+
+ Int_t channel = pmNumber % 8;
+
+ Int_t position = -1;
+ if ((pmNumber >= 32) && (pmNumber <= 63)) { // V0-A (matched v40613)
+ position = 1; // AliTRDptrgParam::kA
+ }
+ else if ((pmNumber >= 0) && (pmNumber <= 31)) { // V0-C (matched v40613)
+ position = 2; // kB
+ }
+
+ AliDebug(5,
+ Form("pmNumber: %d; feeBoard: %d; board: %d; channel: %d; position %d",
+ pmNumber, feeBoard, board, channel, position));
+
+ if (position == -1) {
+ AliError("Wrong VZERO pmt position found");
+ loader->UnloadDigits();
+ return -1;
+ }
+
+ // check whether the digits belongs to the current FEB, otherwise omit it
+ if ((position == this->fPosition) && (board == this->fID)) {
+ AliDebug(5, "Found an digit corresponding to the current FEB");
+ Float_t value = digit->ADC();
+ AliDebug(5, Form("ADC value: %f\n", value));
+ Int_t channelBitMask = 0x01;
+ // channel0 => 0x01; channel1=> 0x02; 2^(channel number)
+ channelBitMask <<= channel;
+ if (value >= this->fThreshold[channel]) {
+ inputVector |= channelBitMask;
+ AliDebug(5,
+ Form("Threshold exceeded in channel %d, new inputVector 0x%x",
+ channel, inputVector));
+ }
+ }
+ }
+
+ AliDebug(5, Form("inputVector: 0x%x", inputVector));
+ loader->UnloadDigits();
+ return inputVector;
+ }
+ else if (this->fType == AliTRDptrgParam::kTZERO) {
+ // load T0's digits --------------------------------------------------------
+ AliLoader * fT0Loader = this->fRunLoader->GetLoader("T0Loader");
+ // AliT0digit *fDigits;
+ if (!fT0Loader) {
+ AliError("Cannot get T0 loader");
+ return -1;
+ }
+
+ fT0Loader->LoadDigits("READ");
+ // Creating T0 data container
+
+ TTree* treeD = fT0Loader->TreeD();
+ if (!treeD) {
+ AliError("no digits tree");
+ return -1;
+ }
+ AliT0digit* digits = new AliT0digit();
+ TBranch *brDigits = treeD->GetBranch("T0");
+
+ if (brDigits) {
+ brDigits->SetAddress(&digits);
+ }
+ else {
+ AliError("Branch T0 DIGIT not found");
+ return -1;
+ }
+ brDigits->GetEntry(0);
+
+ TArrayI qtc0(24); // Array must have 24 entries!
+ TArrayI qtc1(24); // Array must have 24 entries!
+
+ digits->GetQT0(qtc0); // baseline (reference level)
+ digits->GetQT1(qtc1); // measurement value
+
+ Int_t inputVector = 0x0; // vector to be fed into the look up table
+
+ // PMT Positions
+ // C: 0 to 11
+ // A: 12 to 23
+ // positions according to AliT0Digitizer.cxx Revision 37491
+ Int_t nStart = 0;
+ if (this->fPosition == AliTRDptrgParam::kC) { // C
+ nStart = 0;
+ }
+ else if (this->fPosition == AliTRDptrgParam::kA) { // A
+ nStart = 12;
+ }
+
+ Int_t channelBitMask = 0x01;
+ for (Int_t i = 0 + nStart; i < nStart + 12; i++) {
+ //Int_t channelBitMask = 0x01;
+ AliDebug(5, Form("channel: %d", i));
+
+ Int_t value = qtc1[i] - qtc0[i]; // calculate correct measurement value
+
+ if (value > (Int_t)this->fThreshold[i - nStart]) {
+ inputVector |= channelBitMask; // Add bit
+
+ AliDebug(5, Form("Threshold exceeded in channel %d,", i));
+ AliDebug(5, Form("new inputVector 0x%x", inputVector));
+ AliDebug(5, Form("channelBitMask 0x%x", channelBitMask));
+ }
+ channelBitMask <<= 1; // go on to the next channel
+ }
+
+ delete digits;
+ return inputVector;
+ }
+ return -1;
+}
+
+//______________________________________________________________________________
+Int_t AliTRDptrgFEB::LoadAndProcessHits()
+{
+ // loads TO or VO hits and converts them to digits optimized for ptrg
+ // afterwards the digits will be discriminated
+ AliError("LoadAndProcessHits() - not yet implemented!\n");
+ if (this->fType == AliTRDptrgParam::kVZERO) {
+ return 0;
+ }
+ else if (this->fType == AliTRDptrgParam::kTZERO) {
+ return 0;
+ }
+ return -1;
+}
+
+//______________________________________________________________________________
+Bool_t AliTRDptrgFEB::LoadParams()
+{
+ // Load Parameters
+
+ if (this->fParam == 0x0) {
+ AliWarning("No paramater object specified - start loading defaults\n");
+ if (this->fType == AliTRDptrgParam::kVZERO) {
+ // initialize threshold
+ this->fThreshold = new UInt_t[8];
+ for (Int_t i = 0; i < 8; i++) {
+ this->fThreshold[i] = 10;
+ }
+ // initialize LUTsoutputWidth=<value optimized out>
+ AliTRDptrgLUT* lut = new AliTRDptrgLUT();
+ this->fLUTArray.AddLast(lut);
+ lut = new AliTRDptrgLUT();
+ this->fLUTArray.AddLast(lut);
+ // the following lines are only needed for test reasons
+ Int_t* initData = new Int_t[256]; // 2^8
+ lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0));
+ if (lut) {
+ for (Int_t i = 0; i < 256; i++ ) {
+ initData[i] = i;
+ }
+ lut->InitTable(8, 8, initData, kTRUE); // make copy of initData
+ }
+ lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(1));
+ if (lut) {
+ for (Int_t i = 255; i >= 0; i--) {
+ initData[255 - i] = i; // inverse ramp
+ }
+ lut->InitTable(8, 8, initData, kTRUE);
+ }
+ delete [] initData;
+ }
+ else {
+ // initialize threshold
+ this->fThreshold = new UInt_t[12];
+ for (Int_t i = 0; i < 12; i++) {
+ this->fThreshold[i] = 10;
+ }
+
+ // initialize LUTsoutputWidth=<value optimized out>
+ AliTRDptrgLUT* lut = new AliTRDptrgLUT();
+ this->fLUTArray.AddLast(lut);
+ lut = new AliTRDptrgLUT(); // this->fRunLoader
+ this->fLUTArray.AddLast(lut);
+ // the following lines are only needed for test reasons
+ lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0));
+ Int_t* initData = new Int_t[4096]; // 2^12
+ if (lut) {
+ for (Int_t i = 0; i < 4096; i++ ) {
+ initData[i] = i;
+ }
+ lut->InitTable(12, 12, initData, kTRUE); // make a copy of the table
+ }
+ lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(1));
+ if (lut) {
+ //for (Int_t i = 4095; i >= 0; i--) {
+ for (Int_t i = 4096; i > 0; i--) {
+ initData[4096 - i] = i; // inverse ramp
+ }
+ lut->InitTable(12, 12, initData, kTRUE); // make a copy of the table
+ }
+ delete [] initData;
+ }
+ return false;
+ }
+ else {
+ // load parameters from object
+ if (this->fType == AliTRDptrgParam::kVZERO) {
+ // threshold
+ this->fThreshold =
+ this->fParam->GetFEBV0Thresholds(this->fPosition, (this->fID - 1));
+
+ // look up tables
+ // 1
+ AliTRDptrgLUT* LUT = new AliTRDptrgLUT();
+ LUT->InitTable(8, 8, this->fParam->GetFEBV0LUT(this->fPosition,
+ (this->fID - 1),
+ 0), kFALSE);
+ // do not make a copy of the table due to performance reasons
+ this->fLUTArray.AddLast(LUT);
+
+ // 2
+ LUT = new AliTRDptrgLUT();
+ LUT->InitTable(8, 8, this->fParam->GetFEBV0LUT(this->fPosition,
+ (this->fID - 1),
+ 1), kFALSE);
+ // do not make a copy of the table due to performance reasons
+ this->fLUTArray.AddLast(LUT);
+ }
+ else {
+ // threshold
+ this->fThreshold =
+ this->fParam->GetFEBT0Thresholds(this->fPosition);
+
+ // look up tables
+ // 1
+ AliTRDptrgLUT* LUT = new AliTRDptrgLUT();
+ LUT->InitTable(12, 12, fParam->GetFEBT0LUT(this->fPosition, 0), kFALSE);
+ // do not make a copy of the table due to performance reasosn
+ this->fLUTArray.AddLast(LUT);
+
+ // 2
+ LUT = new AliTRDptrgLUT();
+ LUT->InitTable(12, 12, fParam->GetFEBT0LUT(this->fPosition, 1), kFALSE);
+ // do not make a copy of the table due to performance reasosn
+ this->fLUTArray.AddLast(LUT);
+ }
+ return true;
+ }
+
+ return false;
+}
+
+//______________________________________________________________________________
+Int_t* AliTRDptrgFEB::Simulate()
+{
+ // simulates the FEB behavior and returns a 2 bit ouput
+ // (least significant bits)
+
+ Int_t *result = new Int_t;
+ (*result) = -1;
+ if (this->fOperatingMode == AliTRDptrgParam::kDigits) {
+ Int_t inputVector = this->LoadDigits();
+ delete result; // delete error return value
+
+ // perform look up
+ Int_t nLUTs = this->fLUTArray.GetEntriesFast(); // get LUT count
+ result = new Int_t[nLUTs + 1]; // generate new return array
+ result[0] = nLUTs; // storage array length in the first array value
+ for (Int_t iLUT = 0; iLUT < nLUTs; iLUT++) {
+ // process the return value for each LUT and store the result in the array
+ AliDebug(4, Form("FEB: (pos=%d,id=%d,lut=%d,vector=0x%x)",
+ this->fPosition, this->fID, iLUT, inputVector));
+
+ AliTRDptrgLUT *lutTmp = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray[iLUT]);
+ if (lutTmp) {
+ result[iLUT + 1] = lutTmp->LookUp(inputVector);
+ }
+ AliDebug(4, Form("FEB result[%d] = 0x%x",(iLUT + 1),result[iLUT + 1]));
+ }
+ }
+ else if (this->fOperatingMode == AliTRDptrgParam::kHits) {
+ return result;
+ }
+ return result;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff