[u/mrichter/AliRoot.git] / TRD / AliTRDptrgFEB.cxx

/**************************************************************************
 * 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 "AliRunLoader.h"
#include "AliLog.h"

#include "../VZERO/AliVZEROdigit.h" 
#include "../T0/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(kUndefined),
  fOperatingMode(kDigits),
  fInputChannelCount(0),
  fPosition(kUnknown),  
  fID(0),
  fThreshold(0)
{
  // default constructor
  AliError("default ctor - not recommended");
}

//______________________________________________________________________________
AliTRDptrgFEB::AliTRDptrgFEB(AliRunLoader *rl, AliTRDptrgFEBType_t febType, 
                             AliTRDptrgOperatingMode_t operatingMode,
                             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 == kVZERO) {
    // load V0's digits --------------------------------------------------------
    
    // get V0 run loader
    AliLoader* loader = this->fRunLoader->GetLoader( "VZEROLoader" );

    if (!loader) {
      AliError("Can not get VZERO loader");
      return -1;
    }
    loader->LoadDigits("READ");
    TTree* vzeroDigitsTree = loader->TreeD();

    if (!vzeroDigitsTree) {
      AliError("Can not 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;
      Int_t channel = pmNumber % 8;
      Int_t position = pmNumber / 32 + 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));
    
    return inputVector;
  }
  else if (this->fType == kTZERO) {
    // load T0's digits --------------------------------------------------------
    AliLoader * fT0Loader = this->fRunLoader->GetLoader("T0Loader");
    //   AliT0digit *fDigits; 
    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 == kC) { // C
      nStart = 0;
    }
    else if (this->fPosition == 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 == kVZERO) {		
    return 0;
  }
  else if (this->fType == 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 == 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
      lut = dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray.At(0));
      Int_t* initData = new Int_t[256]; // 2^8
      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));
      for (Int_t i = 255; i >= 0; i--) {
        initData[255 - i] = i;  // inverse ramp
      }
      lut->InitTable(8, 8, initData, kTRUE);
    }
    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
      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));
      for (Int_t i = 4095; 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 == 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 == 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));

      result[iLUT + 1] = 
       dynamic_cast<AliTRDptrgLUT*>(this->fLUTArray[iLUT])->LookUp(inputVector);
      AliDebug(4, Form("FEB result[%d] = 0x%x",(iLUT + 1),result[iLUT + 1])); 
    }
  }
  else if (this->fOperatingMode == kHits) {
    return result;
  }
  return result;
}
Commit	Line	Data
f9720615	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
e51605d9	59	AliError("default ctor - not recommended");
f9720615	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
e51605d9	107	AliLoader* loader = this->fRunLoader->GetLoader( "VZEROLoader" );
f9720615	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);
e51605d9	126
e51605d9	127
f9720615	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();
e51605d9	140	Int_t board = pmNumber / 8;
f9720615	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");
f9720615	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]) {
f9720615	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
f9720615	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++) {
e51605d9	258	this->fThreshold[i] = 10;
f9720615	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++) {
e51605d9	282	this->fThreshold[i] = 10;
f9720615	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	}