ROOT logo
/**************************************************************************
 * 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$ */

////////////////////////////////////////////////////////////////////////////
//                                                                        
//  Parameters for Pre-Trigger Simulation                                 
//                                                                        
//  Author: F. Reidt (Felix.Reidt@cern.ch)                                
//               
//  This class controls the parameters used by the pretrigger simulation.
//  A configuration file ca be loaded by calling LoadConfigurationFromFile()
//  The generation of look up tables is also done in this class and has to
//  be done only once after a configuration file was loaded.
//  If no configuration file was loaded, the standard
//  configuration in LoadStandardConfiguration() would be used.
//                                                        
////////////////////////////////////////////////////////////////////////////
#include "TArrayI.h"
#include "TObjString.h"
#include "TString.h"

#include <fstream>

#include "AliLog.h"

#include "AliTRDptrgParam.h"

using std::ifstream;
ClassImp(AliTRDptrgParam)

AliTRDptrgParam *AliTRDptrgParam::fgInstance = 0;


//______________________________________________________________________________
AliTRDptrgParam::AliTRDptrgParam()
  : TObject(),
    fTLMUInputStretch(0),
    fTLMUcmatrices(0x0),
    fTLMUmultiplicity(0x0), 
    fTLMUoutput(0x0),
    fFEBT0Thresholds(0x0),
    fFEBT0Multiplicities(0x0),
    fFEBT0LUTs(0x0),
    fFEBV0Thresholds(0x0),
    fFEBV0Multiplicities(0x0),
    fFEBV0LUTs(0x0),
    fCBLUTs(0x0),
    fPTmasks(AliTRDptrgPTmasks())
{
  // ctor
  
  // initialize coincidence matrices
  this->fTLMUcmatrices = new UInt_t*[3];
  for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
    this->fTLMUcmatrices[iMatrix] = new UInt_t[18];
    for (UInt_t iSlice = 0; iSlice < 18; iSlice++) {
      this->fTLMUcmatrices[iMatrix][iSlice] = 0;
    }
  }
  
  // initialize multiplicity slices
  this->fTLMUmultiplicity = new UInt_t*[9];
  for (UInt_t iSlice = 0; iSlice < 9; iSlice++) {
    this->fTLMUmultiplicity[iSlice] = new UInt_t[2];
    this->fTLMUmultiplicity[iSlice][0] = 577; // disabled
    this->fTLMUmultiplicity[iSlice][1] = 0;
  }
  
  // initialize output muxer
  this->fTLMUoutput = new Int_t*[8];
  for (UInt_t iBit = 0; iBit < 8; iBit++) {
    this->fTLMUoutput[iBit] = new Int_t[2];
    this->fTLMUoutput[iBit][0] = -1; // cmatrix disabled
    this->fTLMUoutput[iBit][1] = -1; // multslice disabled
  }
  
  // initialize T0 FEB thresholds
  this->fFEBT0Thresholds = new UInt_t*[2];
  this->fFEBT0Thresholds[0] = new UInt_t[12];
  this->fFEBT0Thresholds[1] = new UInt_t[12];
  for (Int_t iChan = 0; iChan < 12; iChan++) {
    this->fFEBT0Thresholds[0][iChan] = 4294967295U; 
    this->fFEBT0Thresholds[1][iChan] = 4294967295U;
    // writing 2^32-1 disables the input because all used adcs have 
    // less than 32 bits
  }
  
  // initialize T0 Multiplicity
  this->fFEBT0Multiplicities = new UInt_t**[2];
  this->fFEBT0Multiplicities[0] = new UInt_t*[2];
  this->fFEBT0Multiplicities[1] = new UInt_t*[2];
  this->fFEBT0Multiplicities[0][0] = new UInt_t[2];
  this->fFEBT0Multiplicities[0][1] = new UInt_t[2];
  this->fFEBT0Multiplicities[1][0] = new UInt_t[2];
  this->fFEBT0Multiplicities[1][1] = new UInt_t[2];
  this->fFEBT0Multiplicities[0][0][0] = 4294967295U;
  this->fFEBT0Multiplicities[0][0][1] = 4294967295U;
  this->fFEBT0Multiplicities[0][1][0] = 4294967295U;
  this->fFEBT0Multiplicities[0][1][1] = 4294967295U;
  this->fFEBT0Multiplicities[1][0][0] = 4294967295U;
  this->fFEBT0Multiplicities[1][0][1] = 4294967295U;
  this->fFEBT0Multiplicities[1][1][0] = 4294967295U;
  this->fFEBT0Multiplicities[1][1][1] = 4294967295U;
  // writing 2^32-1 disables the input because all used adcs have 
  // less than 32 bits

  // initialize T0 LUTs
  // this->fFEBT0LUTs = 0x0; (done in member initialization list)
  // further initialization is done in AliTRDptrgParam::GenerateLUTs()
  

  // initialize V0 FEB Thresholds
  this->fFEBV0Thresholds = new UInt_t**[2];
  for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
    this->fFEBV0Thresholds[iPosition] = new UInt_t*[4];
    for (UInt_t iCard = 0; iCard < 4; iCard++) {
      this->fFEBV0Thresholds[iPosition][iCard] = new UInt_t[8];
      for (UInt_t iChannel = 0; iChannel < 8; iChannel++) {
        this->fFEBV0Thresholds[iPosition][iCard][iChannel] = 4294967295U;
      }
    }
  }
 
  // initialize V0 Multiplicities
  this->fFEBV0Multiplicities = new UInt_t***[2];
  for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
    this->fFEBV0Multiplicities[iPosition] = new UInt_t**[4];
    for (UInt_t iCard = 0; iCard < 4; iCard++) {
      this->fFEBV0Multiplicities[iPosition][iCard] = new UInt_t*[2];
      for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
        this->fFEBV0Multiplicities[iPosition][iCard][iLUT] = new UInt_t[2];
        this->fFEBV0Multiplicities[iPosition][iCard][iLUT][0] = 4294967295U;
        this->fFEBV0Multiplicities[iPosition][iCard][iLUT][1] = 0x0;      
      }
    }
  }
  
  // initialize V0 LUTs
  //  this->fFEBV0LUTs = 0x0; (done in member initialization list)
  // further initialization is done in AliTRDptrgParam::GenerateLUTs()

  // initialize CB LUTs
  // this->fCBLUTs = 0x0; (done in member initialization list)
  // further initialization is done in AliTRDptrgParam::GenerateLUTs()

  this->LoadStandardConfiguration(); // load standard configuration
}

//______________________________________________________________________________
AliTRDptrgParam::~AliTRDptrgParam() 
{
  // dtor
  
  // delete coincidence matrices
  if (this->fTLMUcmatrices != 0x0) {
    for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
      if (this->fTLMUcmatrices[iMatrix] != 0x0) {
        delete[] this->fTLMUcmatrices[iMatrix];
        this->fTLMUcmatrices[iMatrix] = 0x0;
      }
    }
    delete[] this->fTLMUcmatrices;
    this->fTLMUcmatrices = 0x0;
  }
  
  // delete multiplicity slices
  if (this->fTLMUmultiplicity != 0x0) {
    for (UInt_t iSlice = 0; iSlice < 9; iSlice++) {
      if (this->fTLMUmultiplicity[iSlice] != 0x0) {
        delete[] this->fTLMUmultiplicity[iSlice];
        this->fTLMUmultiplicity[iSlice] = 0x0;
      }
    }
    delete[] this->fTLMUmultiplicity;
    this->fTLMUmultiplicity = 0x0;
  }

  // delete output mux
  if (this->fTLMUoutput != 0x0) {
    for (UInt_t iBit = 0; iBit < 8; iBit++) {
      if (this->fTLMUoutput[iBit] != 0x0) {
        delete[] this->fTLMUoutput[iBit];
        this->fTLMUoutput[iBit] = 0x0;
      }
    }
    delete[] this->fTLMUoutput;
    this->fTLMUoutput = 0x0;
  }

  // delete T0 FEB thresholds
  if (this->fFEBT0Thresholds != 0x0) {
    if (this->fFEBT0Thresholds[0] != 0x0) {
      delete[] this->fFEBT0Thresholds[0];
      this->fFEBT0Thresholds[0] = 0x0;
    }
    if (this->fFEBT0Thresholds[1] != 0x0) {
      delete[] this->fFEBT0Thresholds[1];
      this->fFEBT0Thresholds[1] = 0x0;
    }
    delete[] this->fFEBT0Thresholds;
    this->fFEBT0Thresholds = 0x0;
  }
 
  // delete T0 multiplicities
  if (this->fFEBT0Multiplicities != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBT0Multiplicities[iPosition] != 0x0) {
        for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
          if (this->fFEBT0Multiplicities[iPosition][iLUT] != 0x0) {
            delete[] this->fFEBT0Multiplicities[iPosition][iLUT];
            this->fFEBT0Multiplicities[iPosition][iLUT] = 0x0;
          }
	}
        delete[] this->fFEBT0Multiplicities[iPosition];
	this->fFEBT0Multiplicities[iPosition] = 0x0;
      }
    }
    delete[] this->fFEBT0Multiplicities;
    this->fFEBT0Multiplicities = 0x0;
  }  

  // delete T0 LUTs
  if (this->fFEBT0LUTs != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBT0LUTs[iPosition] != 0x0) {
        for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
          if (this->fFEBT0LUTs[iPosition][iLUT] != 0x0) {
            delete[] this->fFEBT0LUTs[iPosition][iLUT];
            this->fFEBT0LUTs[iPosition][iLUT] = 0x0;
          }
	}
        delete[] this->fFEBT0LUTs[iPosition];
	this->fFEBT0LUTs[iPosition] = 0x0;
      }
    }
    delete[] this->fFEBT0LUTs;
    this->fFEBT0LUTs = 0x0;
  }  

  // delete V0 FEB thresholds
  if (this->fFEBV0Thresholds != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBV0Thresholds[iPosition] != 0x0) {
        for (UInt_t iCard = 0; iCard < 4; iCard++) {
          if (this->fFEBV0Thresholds[iPosition][iCard] != 0x0) {
            delete[] this->fFEBV0Thresholds[iPosition][iCard];
            this->fFEBV0Thresholds[iPosition][iCard] = 0x0;
	  }
	}
        delete[] this->fFEBV0Thresholds[iPosition]; 
        this->fFEBV0Thresholds[iPosition] = 0x0;
      }
    }
    delete[] this->fFEBV0Thresholds;
    this->fFEBV0Thresholds = 0x0;
  }

  // delete V0 multiplicities
  if (this->fFEBV0Multiplicities != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBV0Multiplicities[iPosition] != 0x0) {
        for (UInt_t iCard = 0; iCard < 4; iCard++) {
          if (this->fFEBV0Multiplicities[iPosition][iCard] != 0x0) {
            for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
              if (this->fFEBV0Multiplicities[iPosition][iCard][iLUT] != 0x0) {
                delete[] this->fFEBV0Multiplicities[iPosition][iCard][iLUT];
                this->fFEBV0Multiplicities[iPosition][iCard][iLUT] = 0x0;
	      }
	    }
            delete[] this->fFEBV0Multiplicities[iPosition][iCard];
            this->fFEBV0Multiplicities[iPosition][iCard] = 0x0;
	  }
	}
        delete[] this->fFEBV0Multiplicities[iPosition]; 
        this->fFEBV0Multiplicities[iPosition] = 0x0;
      }
    }
    delete[] this->fFEBV0Multiplicities;
    this->fFEBV0Multiplicities = 0x0;
  } 

  // delete V0 LUTs
  if (this->fFEBV0LUTs != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBV0LUTs[iPosition] != 0x0) {
        for (UInt_t iCard = 0; iCard < 4; iCard++) {
          if (this->fFEBV0LUTs[iPosition][iCard] != 0x0) {
            for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
              if (this->fFEBV0LUTs[iPosition][iCard][iLUT] != 0x0) {
                delete[] this->fFEBV0LUTs[iPosition][iCard][iLUT];
                this->fFEBV0LUTs[iPosition][iCard][iLUT] = 0x0;
	      }
	    }
            delete[] this->fFEBV0LUTs[iPosition][iCard];
            this->fFEBV0LUTs[iPosition][iCard] = 0x0;
	  }
	}
        delete[] this->fFEBV0LUTs[iPosition]; 
        this->fFEBV0LUTs[iPosition] = 0x0;
      }
    }
    delete[] this->fFEBV0LUTs;
    this->fFEBV0LUTs = 0x0;
  } 

  // delete CB LUTs
  if (this->fCBLUTs != 0x0) {
    for (UInt_t iCB = 0; iCB < 3; iCB++) {
      if (this->fCBLUTs[iCB] != 0x0) {
        for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
          if (this->fCBLUTs[iCB][iLUT] != 0x0) {
            delete[] this->fCBLUTs[iCB][iLUT];
            this->fCBLUTs[iCB][iLUT] = 0x0;
          }
	}
        if (iCB == kB) {
          // CB-B has 3 LUTs!
          if (this->fCBLUTs[iCB][2] != 0x0) {
            delete[] this->fCBLUTs[iCB][2];
            this->fCBLUTs[iCB][2] = 0x0;
          }
        }
        delete[] this->fCBLUTs[iCB];
	this->fCBLUTs[iCB] = 0x0;
      }
    }
    delete[] this->fCBLUTs;
    this->fCBLUTs = 0x0;
  }  
}

//______________________________________________________________________________
Int_t AliTRDptrgParam::CheckVariables() const
{
  // checks whether variables are deleted early enough
 
  // check coincidence matrices
  if (this->fTLMUcmatrices != 0x0) {
    for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
      if (this->fTLMUcmatrices[iMatrix] == 0x0) {
        return -1;
      }
    }
  }
  else {
    return -2;
  }
  
  // check multiplicity slices
  if (this->fTLMUmultiplicity != 0x0) {
    for (UInt_t iSlice = 0; iSlice < 9; iSlice++) {
      if (this->fTLMUmultiplicity[iSlice] == 0x0) {
        return -3;
      }
    }
  }
  else {
    return -4;
  }

  // check output mux
  if (this->fTLMUoutput != 0x0) {
    for (UInt_t iBit = 0; iBit < 8; iBit++) {
      if (this->fTLMUoutput[iBit] == 0x0) {
        return -5;
      }
    }
  }
  else {
    return -6;
  }

  // check T0 FEB thresholds
  if (this->fFEBT0Thresholds != 0x0) {
    if (this->fFEBT0Thresholds[0] == 0x0) {
      return -7;
    }
    if (this->fFEBT0Thresholds[1] == 0x0) {
      return -8;
    }
  }
  else {
    return -9;
  }

  // check T0 multiplicities
  if (this->fFEBT0Multiplicities != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBT0Multiplicities[iPosition] != 0x0) {
        for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
          if (this->fFEBT0Multiplicities[iPosition][iLUT] == 0x0) {
            return -10;
          }
	}
      }
      else {
        return -11;
      }
    }
  }
  else {
    return -12;
  }
  

  // check T0 LUTs
  if (this->fFEBT0LUTs != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBT0LUTs[iPosition] != 0x0) {
        for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
          if (this->fFEBT0LUTs[iPosition][iLUT] == 0x0) {
            return -13;
          }
	}
      }
      else {
        return -14;
      }
    }
  }  
  else {
    return -15;
  }

  // check V0 FEB thresholds
  if (this->fFEBV0Thresholds != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBV0Thresholds[iPosition] != 0x0) {
        for (UInt_t iCard = 0; iCard < 4; iCard++) {
          if (this->fFEBV0Thresholds[iPosition][iCard] == 0x0) {
            return -16;
	  }
	}
      }
      else {
        return -17;
      }
    }
  }
  else {
    return -18;
  }

  // check V0 multiplicities
  if (this->fFEBV0Multiplicities != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBV0Multiplicities[iPosition] != 0x0) {
        for (UInt_t iCard = 0; iCard < 4; iCard++) {
          if (this->fFEBV0Multiplicities[iPosition][iCard] != 0x0) {
            for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
              if (this->fFEBV0Multiplicities[iPosition][iCard][iLUT] == 0x0) {
                return -19;
	      }
	    }
	  }
          else {
            return -20;
	  }
	}
      }
      else {
        return -21;
      }
    }
  } 
  else {
    return -22;
  }

  // check V0 LUTs
  if (this->fFEBV0LUTs != 0x0) {
    for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
      if (this->fFEBV0LUTs[iPosition] != 0x0) {
        for (UInt_t iCard = 0; iCard < 4; iCard++) {
          if (this->fFEBV0LUTs[iPosition][iCard] != 0x0) {
            for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
              if (this->fFEBV0LUTs[iPosition][iCard][iLUT] == 0x0) {
                return -23;
	      }
	    }
	  }
          else {
            return -24;
	  }
	}
      }
      else {
        return -25;
      }
    }
  } 
  else {
    return -26;
  }

  // check CB LUTs
  if (this->fCBLUTs != 0x0) {
    for (UInt_t iCB = 0; iCB < 3; iCB++) {
      if (this->fCBLUTs[iCB] != 0x0) {
        for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
          if (this->fCBLUTs[iCB][iLUT] == 0x0) {
            return -27;
          }
	}
        if (iCB == kB) {
          if (this->fCBLUTs[iCB][2] == 0x0) {
            return -28;
          }
        }
      }
      else {
        return -29;
      }
    }
  }  
  else {
    return -30;
  }
  return 0;
}

//______________________________________________________________________________
AliTRDptrgParam* AliTRDptrgParam::Instance() 
{
  // get (or create) the single instance

  if (fgInstance == 0) 
    fgInstance = new AliTRDptrgParam();

  return fgInstance;
}

//______________________________________________________________________________
void AliTRDptrgParam::Terminate() 
{
  // destruct the instance

  if (fgInstance != 0) {
    delete fgInstance;
    fgInstance = 0x0;
  }
}

//______________________________________________________________________________
void AliTRDptrgParam::LoadStandardConfiguration() {
  // loads a standard configuration parameters for testing 

  // TLMU Input Masks
  for (UInt_t iSM = 0; iSM < 18; iSM++) {
    this->fTLMUInputMask[iSM] = 0xFFFFFFFF; // enable all input bits
  }
 
  // TLMU Input Stretch
  this->fTLMUInputStretch = 0; // not used in simulation

  // TLMU Coincidence Matrices
  //
  // Matrix 0: Back-To-Back
  // Matrix 1: Back-To-Back +/-1
  // Matrix 2: Back-To-Back +/-2
  for (UInt_t iMatrix = 0; iMatrix < 3; iMatrix++) {
    for (UInt_t iSlice = 0; iSlice < 18; iSlice++) {
      if (iMatrix == 0) {
        if (iSlice < 9) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x201 << iSlice; 
          // Back-To-Back 
          AliDebug(5, Form("fTLMUcmatrices[%d][%d]=0x%x",iMatrix,iSlice,
                           this->fTLMUcmatrices[iMatrix][iSlice]));
	}
        // because of symmetrie the other slices are not necessary
      } 
      else if (iMatrix == 1)  {
        // Back-To-Back +/- 1
        if (iSlice < 8) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x381 << iSlice;
        }
        else if (iSlice == 8) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x30101;
        }
        else if (iSlice == 9) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x20203;
        }
        else {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x407 << (iSlice - 10);
        } 
        AliDebug(5, Form("fTLMUcmatrices[%d][%d]=0x%x",iMatrix,iSlice,
                         this->fTLMUcmatrices[iMatrix][iSlice])); 
      }
      else if (iMatrix == 2) {
        // Back-To-Back +/-2
        if (iSlice < 7 ) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0xF81 << iSlice;
        }
        else if (iSlice == 7) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x3C081;
        }
        else if (iSlice == 8) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x38103;
        }
        else if (iSlice == 9) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x30207;
        }
        else if (iSlice == 10) {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x2040F;
        }
        else {
          this->fTLMUcmatrices[iMatrix][iSlice] = 0x81F << (iSlice - 11);
        } 
        AliDebug(5, Form("fTLMUcmatrices[%d][%d]=0x%x",iMatrix,iSlice,
                         this->fTLMUcmatrices[iMatrix][iSlice]));     
      }
    } 
  }

  // TLMU Mulitplicity
  this->fTLMUmultiplicity[0][0] = 0;
  this->fTLMUmultiplicity[0][1] = 10;
  this->fTLMUmultiplicity[1][0] = 10;
  this->fTLMUmultiplicity[1][1] = 25;
  this->fTLMUmultiplicity[2][0] = 25;
  this->fTLMUmultiplicity[2][1] = 50;
  this->fTLMUmultiplicity[3][0] = 50;
  this->fTLMUmultiplicity[3][1] = 100;
  this->fTLMUmultiplicity[4][0] = 100;
  this->fTLMUmultiplicity[4][1] = 200;
  this->fTLMUmultiplicity[5][0] = 200;
  this->fTLMUmultiplicity[5][1] = 350;
  this->fTLMUmultiplicity[6][0] = 350;
  this->fTLMUmultiplicity[6][1] = 400;
  this->fTLMUmultiplicity[7][0] = 400;
  this->fTLMUmultiplicity[7][1] = 576;
  this->fTLMUmultiplicity[8][0] = 1;
  this->fTLMUmultiplicity[8][1] = 576;
 
  // TLMU output
  this->fTLMUoutput[0][0] = 0;
  this->fTLMUoutput[1][0] = 1;
  this->fTLMUoutput[2][0] = 2;
  this->fTLMUoutput[3][1] = 0;
  this->fTLMUoutput[4][1] = 1;
  this->fTLMUoutput[5][1] = 2;
  this->fTLMUoutput[6][1] = 3;
  this->fTLMUoutput[7][1] = 8;

  // T0 FEB Thresholds
  for (UInt_t iChannel = 0; iChannel < 12; iChannel++) {
    this->fFEBT0Thresholds[0][iChannel] = 10;
    this->fFEBT0Thresholds[1][iChannel] = 10;
  }

  // T0 Multiplicities
  for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
    for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
      if (iLUT == 0) {
        this->fFEBT0Multiplicities[iPosition][iLUT][0] = 0;
      }
      else {
	this->fFEBT0Multiplicities[iPosition][iLUT][0] = 5;
      }
      this->fFEBT0Multiplicities[iPosition][iLUT][1] = 0xFFF;
    }
  }

  // V0 FEB Thresholds
  for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
    for (UInt_t iCard = 0; iCard < 4; iCard++) {
      for (UInt_t iChannel = 0; iChannel < 8; iChannel++) {
        this->fFEBV0Thresholds[iPosition][iCard][iChannel] = 10;
      }
    }
  }

  // V0 Multiplicities
  for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
    for (UInt_t iCard = 0; iCard < 4; iCard++) {
      for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
        if (iLUT == 0) {
          this->fFEBV0Multiplicities[iPosition][iCard][iLUT][0] = 0;
        }
        else {
          this->fFEBV0Multiplicities[iPosition][iCard][iLUT][0] = 3;
        }
        this->fFEBV0Multiplicities[iPosition][iCard][iLUT][1] = 0xFF;
      }
    }
  }

  // CB-A LUT equations
  this->fCBALUTequ[0] = "T0_0 || (V0-0_0 || V0-1_0 || V0-2_0 || V0-3_0)";
  this->fCBALUTequ[1] = "!T0_1 && !V0-0_1 && !V0-1_1 && !V0-2_1 && !V0-3_1";

  // CB-C LUT equations
  this->fCBCLUTequ[0] = "T0_0 || ( V0-0_0 || V0-1_0 || V0-2_0 || V0-3_0 )";
  this->fCBCLUTequ[1] = "!T0_1 && !V0-0_1 && !V0-1_1 && !V0-2_1 && !V0-3_1";

  // CB-B LUT equations
  this->fCBBLUTequ[0] = "CB-A_1 && !CB-C_1 && TLMU_7";
  this->fCBBLUTequ[1] = "!CB-A_1 && CB-C_1 && TLMU_7";
  this->fCBBLUTequ[2] = "CB-A_1 && CB-C_1 && TLMU_7";

  // PT output mask
  this->fPTmasks.fLUTs[0] = kTRUE;
  this->fPTmasks.fLUTs[1] = kTRUE;
  this->fPTmasks.fLUTs[2] = kTRUE;
  this->fPTmasks.fCBA[0] = kTRUE;
  this->fPTmasks.fCBC[0] = kTRUE;
  for (Int_t i = 1; i < 7; i++) {
    this->fPTmasks.fTLMU[i] = kTRUE;
  }

  return;  
}

//______________________________________________________________________________
Bool_t AliTRDptrgParam::LoadConfigurationFromFile(TString filename) {
  // Reads pretrigger configuration file and forwards identifiers and values
  // to the corresponding parser functions
  // This method is only checking for certain keywords at the beginning of a
  // line in the config file

  ifstream inputFile;
  inputFile.open(filename.Data());
  TString line;
  TString identifier;
  TString value;
  std::string str;


  if (inputFile.is_open())
  {
    AliDebug(5, "---- Reading configuration file ----");
    while (getline(inputFile, str)) {
      line = str;
   
      AliDebug(5, Form("line: %s\n", line.Data()));
      if (line.Index("TLMU") == 0) {
        this->PrepareLine(line, identifier, value);
        if (!this->ParseTLMU(identifier, value)) {
	  return kFALSE;
        }
      }
      else if (line.Index("FEB") == 0) {
        this->PrepareLine(line, identifier, value);
        if (!this->ParseFEB(identifier, value)) {
	  return kFALSE;
        }
      }
      else if (line.Index("CBB") == 0) {
        this->PrepareLine(line, identifier, value);
        if (!this->ParseCBB(identifier, value)) {
          return kFALSE;
	}
      }
      else if ((line.Index("CBA") == 0) ||
               (line.Index("CBC") == 0)) {
        this->PrepareLine(line, identifier, value);
        if (!this->ParseCBAC(identifier, value)) {
          return kFALSE;
	}
      }
    }
    AliDebug(5, "---- Finished reading configuration file ----");
    inputFile.close();
    return kTRUE;
  }
  else
  {
    AliDebug(5, "Error opening configuration file");
    return kFALSE;
  }
  return kTRUE;
}


//______________________________________________________________________________
Int_t AliTRDptrgParam::GenerateLUTs() {
  // generates all LUTs defined inside this object, this schould called only
  // once, after configuration is loaded in order to save cpu time

  // generation method:
  // walk through address space
  // mask address with input mask =>  get multiplicity of masked value
  // if (multiplicity of masked value) > multiplicity condition
  // write 1 in LUT
  
  // T0
  this->fFEBT0LUTs = new Int_t**[2]; // 2 A + C side
  for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
    // iPosition = 0 -> A, iPosition = 1 -> C
    this->fFEBT0LUTs[iPosition] = new Int_t*[2]; // 2 LUTs per side
    for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
      // LUT with 12 input channels 2^12=4096
      this->fFEBT0LUTs[iPosition][iLUT] = new Int_t[4096];
      AliDebug(5, Form("Generate FEBT0LUT[%d][%d]: (0x%x)>%d", iPosition, iLUT,
                       this->fFEBT0Multiplicities[iPosition][iLUT][1],
                       this->fFEBT0Multiplicities[iPosition][iLUT][0]));
      for (UInt_t iEntry = 0; iEntry < 4096; iEntry++) {
        // Check whether that entry belongs to a multiplicity exceeding the 
        // threshold
        if (this->GetMultiplicity(iEntry & 
	      this->fFEBT0Multiplicities[iPosition][iLUT][1]) > 
            this->fFEBT0Multiplicities[iPosition][iLUT][0]) {
          this->fFEBT0LUTs[iPosition][iLUT][iEntry] = 1;
	}
        else {
          // initialize LUT (not done before !)
          this->fFEBT0LUTs[iPosition][iLUT][iEntry] = 0;
        }
        AliDebug(10, Form("FEBT0LUTs[%d][%d][0x%x]=%d", iPosition, iLUT, iEntry,
                         this->fFEBT0LUTs[iPosition][iLUT][iEntry])); 
      }
      AliDebug(5, Form("Generated FEBT0LUTs[%d][%d]", iPosition, iLUT));
    }
  }

  // V0
  this->fFEBV0LUTs = new Int_t***[2]; // 2 A + C side
  for (UInt_t iPosition = 0; iPosition < 2; iPosition++) {
    // iPosition = 0 -> A, iPosition = 1 -> C
    this->fFEBV0LUTs[iPosition] = new Int_t**[4]; // 4 FEBs per side
    for (UInt_t iFEB = 0; iFEB < 4; iFEB++) {
      this->fFEBV0LUTs[iPosition][iFEB] = new Int_t*[2]; // 2 LUTs per FEB
      for (UInt_t iLUT = 0; iLUT < 2; iLUT++) {
      // LUT with 10 input channels 2^10=1024
        this->fFEBV0LUTs[iPosition][iFEB][iLUT] = new Int_t[1024];
        AliDebug(5, Form("Generate FEBV0LUT[%d][%d][%d]: (0x%x)>%d", iPosition, 
                         iFEB, iLUT,
                         this->fFEBV0Multiplicities[iPosition][iFEB][iLUT][1],
                         this->fFEBV0Multiplicities[iPosition][iFEB][iLUT][0]));
        for (UInt_t iEntry = 0; iEntry < 1024; iEntry++) {
          // Check whether that entry belongs to a multiplicity exceeding the 
          // threshold
          if (this->GetMultiplicity(iEntry & 
	        this->fFEBV0Multiplicities[iPosition][iFEB][iLUT][1]) > 
              this->fFEBV0Multiplicities[iPosition][iFEB][iLUT][0]) {
            this->fFEBV0LUTs[iPosition][iFEB][iLUT][iEntry] = 1;
	  }
          else {
            // initialize LUT (not done before !)
            this->fFEBV0LUTs[iPosition][iFEB][iLUT][iEntry] = 0;
          }
          AliDebug(10, Form("FEBV0LUTs[%d][%d][%d][0x%x]=%d", iPosition, iFEB,
                            iLUT, iEntry, 
                            this->fFEBV0LUTs[iPosition][iFEB][iLUT][iEntry]));
        }
        AliDebug(5, Form("Generated FEBV0LUTs[%d][%d][%d]", iPosition, iFEB, 
                         iLUT));
      }
    }
  }

  // ControlBoxes (CB-x)
  // initialize LUTs
  this->fCBLUTs = new Int_t**[3];
  for (Int_t iCB = 0; iCB < 3; iCB++) {
    if (iCB == kB) { // B
      fCBLUTs[iCB] = new Int_t*[3];
      this->fCBLUTs[iCB][0] = 0x0;
      this->fCBLUTs[iCB][1] = 0x0;
      this->fCBLUTs[iCB][2] = 0x0;
    }
    else { // A + C
      fCBLUTs[iCB] = new Int_t*[2];
      this->fCBLUTs[iCB][0] = 0x0;
      this->fCBLUTs[iCB][1] = 0x0;
    }
  }
  
  // CB-A (CB = 1 / kA)
  for (Int_t iLUT = 0; iLUT < 2; iLUT++) {
    this->fCBLUTs[1][iLUT] = this->GenerateLUTbasedOnEq(this->fCBALUTequ[iLUT],
                                                        10,1);
    for (Int_t iEntry = 0; iEntry < 1024; iEntry++) {
      AliDebug(10, Form("fCBLUTs[@A][%d][0x%x]=%d", iLUT, iEntry,
                        this->fCBLUTs[1][iLUT][iEntry]));
    }
  }

  // CB-C (CB = 2 / kC)
  for (Int_t iLUT = 0; iLUT < 2; iLUT++) {
    this->fCBLUTs[2][iLUT] = this->GenerateLUTbasedOnEq(this->fCBCLUTequ[iLUT],
                                                        10,1);
    for (Int_t iEntry = 0; iEntry < 1024; iEntry++) {
      AliDebug(6, Form("fCBLUTs[@C][%d][0x%x]=%d", iLUT, iEntry,
                       this->fCBLUTs[2][iLUT][iEntry]));
    }
  }  
 
  // CB-B (CB = 0 / kB)
  for (Int_t iLUT = 0; iLUT < 3; iLUT++) {
    this->fCBLUTs[0][iLUT] = this->GenerateLUTbasedOnEq(this->fCBBLUTequ[iLUT], 
                                                        12,1);
    for (Int_t iEntry = 0; iEntry < 4096; iEntry++) {
      AliDebug(10, Form("fCBLUTs[@B][%d][0x%x]=%d", iLUT, iEntry,
                        this->fCBLUTs[0][iLUT][iEntry]));
    }
  }

  AliDebug(5, "LUTs were generated!");
  return 0;
}

//______________________________________________________________________________
UInt_t AliTRDptrgParam::GetMultiplicity(UInt_t BitVector) const {
  // returns the multiplicity of a given bit vector
  
  UInt_t result = 0;
  UInt_t temp = 0x01;
  for (UInt_t iBit = 0; iBit < 32; iBit++) {
    if (BitVector & temp) {
      result++;
    }
    temp <<= 1;
  }

  return result;
}

//______________________________________________________________________________
UInt_t AliTRDptrgParam::GetMultiplicity(Int_t BitVector) const {
  // returns the multiplicity of a given bit vector
  
  UInt_t result = 0;
  UInt_t temp = 0x01;
  for (UInt_t iBit = 0; iBit < 32; iBit++) {
    if (BitVector & temp) {
      result++;
    }
    temp <<= 1;
  }

  return result;
}

//______________________________________________________________________________
//
//      Configuration file parsing (helper functions)
//______________________________________________________________________________

//______________________________________________________________________________
void AliTRDptrgParam::PrepareLine(TString line, TString& identifier, 
                                  TString& value) {
  // Prepares a line for parsing
  // divide identifier and value 

  // clear identifier and value
  identifier.Clear();
  value.Clear();  

  Int_t iLetter = 0;
  while ((line[iLetter] != ' ') && (line[iLetter] != '\t') && 
         (line[iLetter] != '#') && (iLetter < line.Length())) {
    // read identifier
    identifier += line[iLetter];
    iLetter++;
  }
  while (((line[iLetter] == ' ') || (line[iLetter] == '\t')) &&
	 (iLetter < line.Length()) && (line[iLetter] != '#')) {
    // omit whitespaces and tabs in between
    iLetter++;
  }
  while(iLetter < line.Length()) {
    // read value or equation and remove white spaces and tabs
    //if ((line[iLetter] != ' ') && (line[iLetter] != '\t') &&
    //    (line[iLetter] != '#')) {
    if (line[iLetter] != '#') {
      value += line[iLetter];
    }
    iLetter++;
  }
}

//______________________________________________________________________________
TString AliTRDptrgParam::CleanTString(TString string) {
  // Removes white spaces and tabs

  TString result;
  result.Clear();
  for (Int_t iLetter = 0; iLetter < string.Length(); iLetter++) {
    if ((string[iLetter] != ' ') && (string[iLetter] != '\t')) {
      result += string[iLetter];
    }
  } 
  AliDebug(5, Form("Cleaned string: %s", result.Data()));  
  return result;
}

//______________________________________________________________________________
void AliTRDptrgParam::SplitUpValues(TString value, TObjArray& arr) {
  // splits up multiple values into a TObjArray

  TString temp;
  temp.Clear();
  temp.Resize(0);
  for (Int_t iLetter = 0; iLetter < value.Length(); iLetter++) {
    if ((value[iLetter] != ' ') && (value[iLetter] != '\t')) {
      // add another letter
      temp += value[iLetter];
    }
    else {
      // seperator found: white space or tabs
      if (temp.Length()) {
        TObjString* t = new TObjString(temp.Data());
        arr.Add(t);      
        temp.Clear();
        temp.Resize(0);
      }
    }
  }
  if (temp.Length() != 0) {
    TObjString* t = new TObjString(temp.Data());
    arr.Add(t);         
  }
}

//______________________________________________________________________________
UInt_t AliTRDptrgParam::BinaryTStringToInt(TString number) const {
  // converts a binary TString to an integer
  UInt_t temp = 0x01;
  UInt_t result = 0x0;
  for (Int_t i = number.Length() - 1; i >= 0; i--) {
    if (number[i] == '1') {
      result |= temp;
      temp <<= 1;
    }
    else if (number[i] == '0')  {
      temp <<= 1;    
    }
  }
  return result;
}

//______________________________________________________________________________
Bool_t AliTRDptrgParam::ParseMultiplicityCondition(TString condition, 
                                                   UInt_t* threshold,
                                                   UInt_t* mask) {
  // converts a string formed like "M(1111_1111)>4" to a input mask and a
  // multiplicity threshold

  // check whether condition is starting with "M(
  if ((condition[0] != 'M') || ( condition[1] != '(')) {
    return kFALSE;
  }
  
  TString maskStr = "";
  Int_t iLetter = 0;
  
  // extract input mask
  while (condition[iLetter] != ')') {
    maskStr += condition[iLetter++];
  }
  (*mask) = BinaryTStringToInt(maskStr);
  if ((*mask) == 0) { 
    AliDebug(5, Form("Invalid input mask: %s,[%s]", maskStr.Data(), 
                      condition.Data()));
    return kFALSE;
  }
  
  // ensure that ')' is followed by a '>'
  if (condition[++iLetter] != '>') {
    AliDebug(5, Form("multiplicity condition is incorrectly formed: %s", 
                     condition.Data()));
    return kFALSE;
  }
  iLetter++; // move on to the first digit

  TString thresholdStr = "";
  // gain threshold string
  while (((condition[iLetter] != ' ') || (condition[iLetter] != '\t')) &&
         (iLetter < condition.Length())) {
    thresholdStr += condition[iLetter++];
  }
  (*threshold) = thresholdStr.Atoi(); // convert string to integer
  AliDebug(5, Form("mask: 0x%x, multiplicity threshold: %d", (*mask), 
                   (*threshold)));
  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliTRDptrgParam::ParseFEB(TString identifier, TString value) {
  // Parse FEB configuration

  //------------------------------------------
  if (identifier.Index("FEB/T0/A/THR") == 0) {
    // FEB T0 thresholds at A side

    TObjArray arr;
    arr.Clear();
    SplitUpValues(value, arr);
    
    if (arr.GetEntries() != 12) {
      AliError("Wrong FEB T0 Threshold count, it must be 12 channels!");
      return kFALSE; 
    }
    for (Int_t iValue = 0; iValue < arr.GetEntries(); iValue++) {
      TObjString *ostrng = dynamic_cast<TObjString*>(arr[iValue]);
      if (ostrng) {
        this->fFEBT0Thresholds[0][iValue] = (ostrng->GetString()).Atoi();
      }
      AliDebug(5, Form("FEB/T0/A/THR[%d]=%d", iValue, 
                       this->fFEBT0Thresholds[0][iValue])); 
    }
    return kTRUE;
  }

  //-----------------------------------------------
  else if (identifier.Index("FEB/T0/C/THR") == 0) {
    // FEB T0 thresholds at c side

    TObjArray arr;
    arr.Clear();
    SplitUpValues(value, arr);
    
    if (arr.GetEntries() != 12) {
      AliError("Wrong FEB T0 Threshold count, it must be 12 channels!");
      return kFALSE; 
    }
    for (Int_t iValue = 0; iValue < arr.GetEntries(); iValue++) {
      TObjString *ostrng = dynamic_cast<TObjString*>(arr[iValue]);
      if (ostrng) {
        this->fFEBT0Thresholds[1][iValue] = (ostrng->GetString()).Atoi();
      }
      AliDebug(5, Form("FEB/T0/C/THR[%d]=%d", iValue, 
                       this->fFEBT0Thresholds[1][iValue])); 
    }
    return kTRUE;
  }
  
  //--------------------------------------------------
  else if ((identifier.Index("FEB/V0/A0/THR") == 0) ||
      (identifier.Index("FEB/V0/A1/THR") == 0) ||
      (identifier.Index("FEB/V0/A2/THR") == 0) ||
      (identifier.Index("FEB/V0/A3/THR") == 0)) {
    // FEB V0 thresholds at a side (cards 0,1,2,3)
   
    TString cardIDstr = identifier(8, 1);
    Int_t cardID = cardIDstr.Atoi();
 
    TObjArray arr;
    arr.Clear();
    SplitUpValues(value, arr);
    
    if (arr.GetEntries() != 8) {
      AliError("Wrong FEB V0 Threshold count, it must be 8 channels!");
      return kFALSE; 
    }
    for (Int_t iValue = 0; iValue < arr.GetEntries(); iValue++) {
      TObjString *ostrng = dynamic_cast<TObjString*>(arr[iValue]);
      if (ostrng) {
        this->fFEBV0Thresholds[0][cardID][iValue] =  
          (ostrng->GetString()).Atoi();
      }
      AliDebug(5, Form("FEB/V0/A%d/THR[%d]=%d", cardID, iValue, 
                       this->fFEBV0Thresholds[0][cardID][iValue])); 
    }
  }

  //--------------------------------------------------
  else if ((identifier.Index("FEB/V0/C0/THR") == 0) ||
      (identifier.Index("FEB/V0/C1/THR") == 0) ||
      (identifier.Index("FEB/V0/C2/THR") == 0) ||
      (identifier.Index("FEB/V0/C3/THR") == 0)) {
    // FEB V0 thresholds at c side (cards 0,1,2,3)
   
    TString cardIDstr = identifier(8, 1);
    Int_t cardID = cardIDstr.Atoi();
 
    TObjArray arr;
    arr.Clear();
    SplitUpValues(value, arr);
    
    if (arr.GetEntries() != 8) {
      AliError("Wrong FEB V0 Threshold count, it must be 8 channels!");
      return kFALSE; 
    }
    for (Int_t iValue = 0; iValue < arr.GetEntries(); iValue++) {
      TObjString *ostrng = dynamic_cast<TObjString*>(arr[iValue]);
      if (ostrng) {
        this->fFEBV0Thresholds[1][cardID][iValue] = (ostrng->GetString()).Atoi();
      }
      AliDebug(5, Form("FEB/V0/C%d/THR[%d]=%d", cardID, iValue, 
                       this->fFEBV0Thresholds[1][cardID][iValue])); 
    }
  }
  
  //-----------------------------------------------
  else if (identifier.Index("FEB/T0/A/LUT") == 0) {
    // FEB T0 look up tables at A side

    TString lutIDstr = identifier(13, 1);
    Int_t lutID = lutIDstr.Atoi();
    
    UInt_t val = 0;
    UInt_t mask = 0;
    ParseMultiplicityCondition(value, &val, &mask);
    this->fFEBT0Multiplicities[0][lutID][0] = val;
    this->fFEBT0Multiplicities[0][lutID][1] = mask;
    AliDebug(5, Form("FEBT0Multiplicities[0/A][%d][val] = %d", lutID, val));
    AliDebug(5, Form("FEBT0Multiplicities[0/A][%d][mask] = %d", lutID, mask));
    
    return kTRUE;
  }

  //-----------------------------------------------
  else if (identifier.Index("FEB/T0/C/LUT") == 0) {
    // FEB T0 look up tables at C side

    TString lutIDstr = identifier(13, 1);
    Int_t lutID = lutIDstr.Atoi();
    
    UInt_t val = 0;
    UInt_t mask = 0;
    ParseMultiplicityCondition(value, &val, &mask);
    this->fFEBT0Multiplicities[1][lutID][0] = val;
    this->fFEBT0Multiplicities[1][lutID][1] = mask;
    AliDebug(5, Form("FEBT0Multiplicities[1/C][%d][val] = %d", lutID, val));
    AliDebug(5, Form("FEBT0Multiplicities[1/C][%d][mask] = %d", lutID, mask));

    return kTRUE;
  }

  //--------------------------------------------------
  else if ((identifier.Index("FEB/V0/A0/LUT") == 0) ||
           (identifier.Index("FEB/V0/A1/LUT") == 0) ||
           (identifier.Index("FEB/V0/A2/LUT") == 0) ||
           (identifier.Index("FEB/V0/A3/LUT") == 0)) {
    // FEB V0 look up tables at A side

    TString cardIDstr = identifier(8, 1);
    Int_t cardID = cardIDstr.Atoi();
 
    TString lutIDstr = identifier(14, 1);
    Int_t lutID = lutIDstr.Atoi();
     
    UInt_t val = 0;
    UInt_t mask = 0;
    ParseMultiplicityCondition(value, &val, &mask);
    this->fFEBV0Multiplicities[0][cardID][lutID][0] = val;
    this->fFEBV0Multiplicities[0][cardID][lutID][1] = mask;
    AliDebug(5, Form("FEBV0Multiplicities[0/A][%d][%d][val] = %d", cardID, 
                     lutID, val));
    AliDebug(5, Form("FEBV0Multiplicities[0/A][%d][%d][mask] = %d", cardID, 
                     lutID, mask));

    return kTRUE;
  }
   
  //--------------------------------------------------
  else if ((identifier.Index("FEB/V0/C0/LUT") == 0) ||
           (identifier.Index("FEB/V0/C1/LUT") == 0) ||
           (identifier.Index("FEB/V0/C2/LUT") == 0) ||
           (identifier.Index("FEB/V0/C3/LUT") == 0)) {
    // FEB V0 look up tables at C side

    TString cardIDstr = identifier(8, 1);
    Int_t cardID = cardIDstr.Atoi();
 
    TString lutIDstr = identifier(14, 1);
    Int_t lutID = lutIDstr.Atoi();
     
    UInt_t val = 0;
    UInt_t mask = 0;
    ParseMultiplicityCondition(value, &val, &mask);
    this->fFEBV0Multiplicities[1][cardID][lutID][0] = val;
    this->fFEBV0Multiplicities[1][cardID][lutID][1] = mask;
    AliDebug(5, Form("FEBV0Multiplicities[1/C][%d][%d][val] = %d", cardID, 
                     lutID, val));
    AliDebug(5, Form("FEBV0Multiplicities[1/C][%d][%d][mask] = %d", cardID, 
                     lutID, mask));

    return kTRUE;
  }
  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliTRDptrgParam::ParseCBAC(TString identifier, TString value) {
  // Parse CB-A and CB-C configuration
 
  if (identifier.Index("CBA/LUT/") == 0) {
    // parse CB-A's logical equations
    
    TString eqIDstr = identifier(8, 1);
    Int_t eqID = eqIDstr.Atoi();
   
    if ((eqID == 0) || (eqID == 1)) {
      this->fCBALUTequ[eqID] = this->CleanTString(value);
      AliDebug(5, Form("fCBALUTequ[%d]=%s", eqID, this->fCBALUTequ[eqID].Data())); 
    }
    return kTRUE;    
  }
    
  else if (identifier.Index("CBC/LUT/") == 0) {
    // parse CB-C's logical equations
    
    TString eqIDstr = identifier(8, 1);
    Int_t eqID = eqIDstr.Atoi();
   
    if ((eqID == 0) || (eqID == 1)) {
      this->fCBCLUTequ[eqID] = this->CleanTString(value);
      AliDebug(5, Form("fCBCLUTequ[%d]=%s", eqID, this->fCBCLUTequ[eqID].Data()));
    }
    return kTRUE;
  }

  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliTRDptrgParam::ParseCBB(TString identifier, TString value) {
  // Parse CBB configuration
  
  if (identifier.Index("CBB/LUT/") == 0) {
    // parse CB-B's logical equations
    
    TString eqIDstr = identifier(8, 1);
    Int_t eqID = eqIDstr.Atoi();
   
    if ((eqID == 0) || (eqID == 1) || (eqID == 2)) {
      this->fCBBLUTequ[eqID] = this->CleanTString(value);
      AliDebug(5, Form("fCBBLUTequ[%d]=%s", eqID, this->fCBBLUTequ[eqID].Data()));
    }
    return kTRUE;
  }
  
  // PT masks 
  else if (identifier.Index("CBB/PT/MASK/CB-A_0") == 0) { // CB-A_0
    if (value.Index("YES") == 0) {
      this->fPTmasks.fCBA[0] = kTRUE;     
    }
    else {
      this->fPTmasks.fCBA[0] = kFALSE;
    }
    AliDebug(5, Form("CBB/PT/MASK/CB-A_0=%d", this->fPTmasks.fCBA[0]));
    return kTRUE;
  }
  else if (identifier.Index("CBB/PT/MASK/CB-A_1") == 0) { // CB-A_1
    if (value.Index("YES") == 0) {
      this->fPTmasks.fCBA[1] = kTRUE;     
    }
    else {
      this->fPTmasks.fCBA[1] = kFALSE;
    }
    AliDebug(5, Form("CBB/PT/MASK/CB-A_1=%d", this->fPTmasks.fCBA[1]));
    return kTRUE;
  } 
  else if (identifier.Index("CBB/PT/MASK/CB-C_0") == 0) { // CB-C_0
    if (value.Index("YES") == 0) {
      this->fPTmasks.fCBC[0] = kTRUE;     
    }
    else {
      this->fPTmasks.fCBC[0] = kFALSE;
    }
    AliDebug(5, Form("CBB/PT/MASK/CB-C_0=%d",this->fPTmasks.fCBC[0]));
    return kTRUE;
  }
  else if (identifier.Index("CBB/PT/MASK/CB-C_1") == 0) { // CB-C_1
    if (value.Index("YES") == 0) {
      this->fPTmasks.fCBC[1] = kTRUE;     
    }
    else {
      this->fPTmasks.fCBC[1] = kFALSE;
    }
    AliDebug(5, Form("CBB/PT/MASK/CB-C_1=%d", this->fPTmasks.fCBC[1]));
    return kTRUE;
  } 
  else if (identifier.Index("CBB/PT/MASK/CB-B_0") == 0) { // CB-B_0
    if (value.Index("YES") == 0) {
      this->fPTmasks.fLUTs[0] = kTRUE;     
    }
    else {
      this->fPTmasks.fLUTs[0] = kFALSE;
    }
    AliDebug(5, Form("CBB/PT/MASK/CB-B_0=%d",this->fPTmasks.fLUTs[0]));
    return kTRUE;
  }
  else if (identifier.Index("CBB/PT/MASK/CB-B_1") == 0) { // CB-B_1
    if (value.Index("YES") == 0) {
      this->fPTmasks.fLUTs[1] = kTRUE;     
    }
    else {
      this->fPTmasks.fLUTs[1] = kFALSE;
    }
    AliDebug(5, Form("CBB/PT/MASK/CB-B_1/=%d", this->fPTmasks.fLUTs[1]));
    return kTRUE;
  }
  else if (identifier.Index("CBB/PT/MASK/CB-B_2") == 0) { // CB-B_2
    if (value.Index("YES") == 0) {
      this->fPTmasks.fLUTs[2] = kTRUE;     
    }
    else {
      this->fPTmasks.fLUTs[2] = kFALSE;
    }
    AliDebug(5, Form("CBB/PT/MASK/CB-B_2/=%d", this->fPTmasks.fLUTs[2]));
    return kTRUE;
  }
  else if (identifier.Index("BB/PT/MASK/TLMU_") == 0) {
    TString indexStr = identifier(16, 1);
    Int_t index = indexStr.Atoi();
    if (value.Index("YES") == 0) {
      this->fPTmasks.fTLMU[index] = kTRUE;
    }
    else {
      this->fPTmasks.fTLMU[index] = kFALSE;
    }
    AliDebug(5, Form("CBB/PT/MASK/TLMU_%d=%d", index, 
                     this->fPTmasks.fTLMU[index]));
    return kTRUE;
  }
  return kTRUE;
}

//______________________________________________________________________________
Bool_t AliTRDptrgParam::ParseTLMU(TString identifier, TString value) {
  // Parse TLMU configuration

  if (identifier.Index("TLMU/IMASK/SEC") == 0) {
    // TLMU input masks
    TString indexStr = identifier(14,2);
    Int_t index = indexStr.Atoi();
    if ((index < 0) || (index > 17)) {
      AliDebug(5, "Wrong section index in TLMU input mask");
      return kFALSE;
    }
    this->fTLMUInputMask[index] = BinaryTStringToInt(value);
    AliDebug(5, Form("%d %x\n", index, this->fTLMUInputMask[index]));
    return kTRUE;
  }

  //-----------------------------------------------
  else if (identifier.Index("TLMU/CMATRIX") == 0) {
    // TLMU coincidence matrices

    // matrix index
    TString matrixIndexStr = identifier(12,1);
    Int_t matrixIndex = matrixIndexStr.Atoi();
    // entry index
    TString indexStr = identifier(17,2);
    Int_t index = indexStr.Atoi();
    this->fTLMUcmatrices[matrixIndex][index] = BinaryTStringToInt(value);
    AliDebug(5, Form("%d 0x%x\n", matrixIndex, 
                     this->fTLMUcmatrices[matrixIndex][index]));
    return kTRUE;
  }

  //---------------------------------------------
  else if (identifier.Index("TLMU/MCNTR") == 0) {
    // TLMU multiplicity counter setup
    
    TString indexStr = identifier(10,1);
    Int_t index = indexStr.Atoi();
    TObjArray arr;

    SplitUpValues(value, arr);
    
    TObjString *ostrng0 = dynamic_cast<TObjString*>(arr[0]);
    TObjString *ostrng1 = dynamic_cast<TObjString*>(arr[1]);

    if (ostrng0 && ostrng1) {

      TString t0 = ostrng0->GetString();
      TString t1 = ostrng1->GetString();
  
      this->fTLMUmultiplicity[index][0] = t0.Atoi();
      this->fTLMUmultiplicity[index][1] = t1.Atoi();
 
      AliDebug(5, Form("%d: %d  %d", index, this->fTLMUmultiplicity[index][0], 
                       this->fTLMUmultiplicity[index][1]));      

    }

    return kTRUE;
  }
  
  //----------------------------------------------
  else if (identifier.Index("TLMU/OUTMUX") == 0) {
    // TLMU output signal assignment
    TObjArray arr;
    SplitUpValues(value, arr);
  
    if (arr.GetEntries() > 8) {
      AliError("Too many TLMU output signals assigned");
      return kFALSE;
    } 
  
    for (Int_t iEntry = 0; iEntry < arr.GetEntries(); iEntry++) {

      TObjString *ostrng = dynamic_cast<TObjString*>(arr[iEntry]);
      if (ostrng) {

        TString t = ostrng->GetString(); 
      
        TString indexStr = t(2,1);
        if (t.Index("CM") == 0) { // coincidence matrix
          this->fTLMUoutput[iEntry][0] = indexStr.Atoi();
        }
        else if (t.Index("MC") == 0) { // multiplicity
          this->fTLMUoutput[iEntry][1] = indexStr.Atoi();
        }

      }

      AliDebug(5, Form("TLMU output: cm = %d, mc = %d", 
                       this->fTLMUoutput[iEntry][0], 
                       this->fTLMUoutput[iEntry][1]));
    }
    return kTRUE;
  }
  return kTRUE;
}

//______________________________________________________________________________
//
//       Logical Equation to LUT processing (helper functions)
//______________________________________________________________________________

//______________________________________________________________________________
Int_t AliTRDptrgParam::LookUp(TString* const identifier) const {
  // Transforms identifier into look up table address bit
  //
  // this function has to be extended/changed when different identifiers for
  // other equations and destination LUTs should be used

  if (identifier->CompareTo("T0_0", TString::kIgnoreCase) == 0)  
    return 0x001;
  else if (identifier->CompareTo("T0_1", TString::kIgnoreCase) == 0) 
    return 0x002; 
  else if (identifier->CompareTo("V0-0_0", TString::kIgnoreCase) == 0) 
    return 0x004; 
  else if (identifier->CompareTo("V0-0_1", TString::kIgnoreCase) == 0) 
    return 0x008; 
  else if (identifier->CompareTo("V0-1_0", TString::kIgnoreCase) == 0) 
    return 0x010; 
  else if (identifier->CompareTo("V0-1_1", TString::kIgnoreCase) == 0) 
    return 0x020; 
  else if (identifier->CompareTo("V0-2_0", TString::kIgnoreCase) == 0) 
    return 0x040; 
  else if (identifier->CompareTo("V0-2_1", TString::kIgnoreCase) == 0) 
    return 0x080; 
  else if (identifier->CompareTo("V0-3_0", TString::kIgnoreCase) == 0) 
    return 0x100; 
  else if (identifier->CompareTo("V0-3_1", TString::kIgnoreCase) == 0) 
    return 0x200; 
  else if (identifier->CompareTo("CB-A_0", TString::kIgnoreCase) == 0) 
    return 0x001; 
  else if (identifier->CompareTo("CB-A_1", TString::kIgnoreCase) == 0) 
    return 0x002; 
  else if (identifier->CompareTo("CB-C_0", TString::kIgnoreCase) == 0) 
    return 0x004; 
  else if (identifier->CompareTo("CB-C_1", TString::kIgnoreCase) == 0) 
    return 0x008; 
  else if (identifier->CompareTo("TLMU_0", TString::kIgnoreCase) == 0)  
    return 0x010; 
  else if (identifier->CompareTo("TLMU_1", TString::kIgnoreCase) == 0) 
    return 0x020; 
  else if (identifier->CompareTo("TLMU_2", TString::kIgnoreCase) == 0) 
    return 0x040; 
  else if (identifier->CompareTo("TLMU_3", TString::kIgnoreCase) == 0) 
    return 0x080; 
  else if (identifier->CompareTo("TLMU_4", TString::kIgnoreCase) == 0) 
    return 0x100; 
  else if (identifier->CompareTo("TLMU_5", TString::kIgnoreCase) == 0) 
    return 0x200; 
  else if (identifier->CompareTo("TLMU_6", TString::kIgnoreCase) == 0) 
    return 0x400; 
  else if (identifier->CompareTo("TLMU_7", TString::kIgnoreCase) == 0) 
    return 0x800; 
  else return 0x0; // Error
}

//______________________________________________________________________________
void AliTRDptrgParam::MergeResults(TArrayI*& partResult1, TArrayI*& partResult2,
                                   TArrayI*& results,
                                   TArrayI*& signalsInvolved1, 
                                   TArrayI*& signalsInvolved2, 
                                   TArrayI*& signalsInvolved, 
                                   Bool_t useOR) {
  // merges result and signal involved arrays
  // uses logical OR (or=kTRUE) and AND (or==kFALSE) as merging function
  
  // check whether input data is valid
  if ((partResult1 == 0x0) || (partResult2 == 0x0) || 
      (signalsInvolved1 == 0x0) || (signalsInvolved2 == 0x0)) {
    AliError("fatal logical equation processing error!");
    return;
  }
 
  // allocate results and signalsInvolved 
  results = new TArrayI(0);    
  signalsInvolved = new TArrayI(0);

  // merge arrays (necessary for OR and AND)
  for (Int_t i = 0; i < partResult1->GetSize(); i++) {
    for (Int_t j = 0; j < partResult2->GetSize(); j++) {
      results->Set(results->GetSize() + 1); // increment size
      (*results)[results->GetSize() - 1] =  // add combination
        (*partResult1)[i] | (*partResult2)[j];
 
      signalsInvolved->Set(signalsInvolved->GetSize() + 1);
      (*signalsInvolved)[signalsInvolved->GetSize() - 1] = 
         (*signalsInvolved1)[i] | (*signalsInvolved2)[j];
    }
  }
  
  if (useOR) { // only necessary for OR
    // add partResult1
    for (Int_t i = 0; i < partResult1->GetSize(); i++) {
      results->Set(results->GetSize() + 1);
      (*results)[results->GetSize() - 1] = (*partResult1)[i];
      
      signalsInvolved->Set(signalsInvolved->GetSize() + 1);
      (*signalsInvolved)[signalsInvolved->GetSize()-1] = (*signalsInvolved1)[i];
    }
    // add partResult2
    for (Int_t i = 0; i < partResult2->GetSize(); i++) {
      results->Set(results->GetSize() + 1);
      (*results)[results->GetSize() - 1] = (*partResult2)[i];
      
      signalsInvolved->Set(signalsInvolved->GetSize() + 1);
      (*signalsInvolved)[signalsInvolved->GetSize()-1] = (*signalsInvolved2)[i];
    }
  }
  
  // debug output
  AliDebug(5, "merging results: ");
  for (Int_t i = 0; i < results->GetSize(); i++) {
    AliDebug(5, Form("0x%x 0x%x", (*results)[i], (*signalsInvolved)[i]));
  }

  // free memory
  delete partResult1;
  partResult1 = 0x0;
  delete partResult2;
  partResult2 = 0x0; 
}

//______________________________________________________________________________
void AliTRDptrgParam::ConvertLogicalEqToBitVectors(TString eq, 
                                                   TArrayI*& results,
                                                   TArrayI*& signalsInvolved) {
  // converts a logical equation to a LUT
  //
  // input string must not contain white spaces or tabs
  // only identifiers, ||, &&, (, ) and ! are allowed
  //
  // neglected signals are assumed to be zero in this function
  // this problem is solved by "void CheckSignalsInvolved(...)"

  AliDebug(5, Form("eq: %s", eq.Data()));

  // temporary variables used before/while merging
  TArrayI* partResult1 = 0x0;
  TArrayI* partResult2 = 0x0;
  TArrayI* partResult3 = 0x0;
  TArrayI* partResult4 = 0x0;
  TArrayI* signalsInvolved1 = 0x0;
  TArrayI* signalsInvolved2 = 0x0;
  TArrayI* signalsInvolved3 = 0x0;
  TArrayI* signalsInvolved4 = 0x0;
 
  Int_t iChar = 0; // counter variable
  
  // variables needed for correct operator order (&& before ||!)
  Int_t foundORbefore = -1; // found an || in that string (-1 = not found)
  Int_t foundAND = -1; // found an &&
  Int_t foundORafter = -1; // found a second OR after &&

  // variables needed for correct bracket processing
  Int_t enteredBrackets = 0; // indicates in which bracket layer the parser is
  Int_t bracketLevelAtZero = -1; // when enteredBrackets = 0 was reached first
  // after it ascended  

  while ((iChar < eq.Length())) { //--------------------------------------------
    // walk through string

    // operators ---------------------------------------------------------------
    if ((enteredBrackets == 0 ) && (eq[iChar] != '(') && (eq[iChar] != ')'))  {
      // '|'
      if (eq[iChar] == '|') {
        if (eq[iChar + 1] == '|') { // ||
          iChar++; // jump to the next charakter
          if (foundAND == -1) {
            foundORbefore = iChar;
          }
          else if ((foundORafter == -1) && (foundAND != -1)) {
            foundORafter = iChar;
          }
        }
        else { // bit-wise and not supported
          AliError(Form("LogicalEquation incorrect: %s", eq.Data()));
          AliError("bit-wise AND (&) not supported for now");
          return;
        }
      }
      // '&' 
      else if (eq[iChar] == '&') {
        if (eq[iChar] == '&') { // ||
          iChar++; // jump to the next charakter
          if (foundAND == -1) {
            foundAND = iChar;
          }
        }
        else { // bit-wise or not supported
          AliError(Form("LogicalEquation incorrect: %s", eq.Data()));
          AliError("bit-wise OR (|) not supported for now");
	  return;
        }
      }
    }
    // brackets ----------------------------------------------------------------
    // '(' 
    if (eq[iChar] == '(') {
      enteredBrackets++;      
    }
    // ')' 
    else if (eq[iChar] == ')') {
      enteredBrackets--;
      if (enteredBrackets < 0) {        
        AliError(Form("LogicalEquation incorrect: %s", eq.Data()));     
        AliError("Too many )s");
      }
      if ((enteredBrackets == 0) && (bracketLevelAtZero == -1) &&
          (foundAND == -1) && (foundORbefore == -1)) {
        // needed to detected equations encapsulated in brackets: (...)
        bracketLevelAtZero = iChar;
      }
    }      
    iChar++; // go on to the next letter/char
  } //--------------------------------------------------------------------------

  if (bracketLevelAtZero == (eq.Length() - 1)) { // strip ( ) and process again
    ConvertLogicalEqToBitVectors(eq(1, eq.Length() -2), results, 
                                 signalsInvolved);
    return;     
  }
  else if (foundAND == -1) { // no AND
    if (foundORbefore != -1) { // only OR / || found and no AND
      ConvertLogicalEqToBitVectors(eq(0, foundORbefore-1), partResult1, 
                                   signalsInvolved1); 
      ConvertLogicalEqToBitVectors(eq(foundORbefore+1, 
                                      eq.Length()-foundORbefore-1),
                                   partResult2, signalsInvolved2);
      
      MergeResults(partResult1, partResult2, results, signalsInvolved1,
                   signalsInvolved2, signalsInvolved, kTRUE);
      return;
    } 
    else { // only identifier remained!
      results = new TArrayI(1);
      signalsInvolved = new TArrayI(1);
      if (eq[0] != '!') { // identifier without negation
        (*results)[0] = LookUp(&eq); 
        (*signalsInvolved)[0] = (*results)[0];
      }
      else { // identifier with negation
        (*results)[0] = 0;
        TString eqNegated = eq(1, eq.Length()-1);
        (*signalsInvolved)[0] = LookUp(&eqNegated);
      } 
      return;
    }
  }
  // found single or multiple AND / && 
  else if ((foundORafter != -1) && (foundORbefore != -1)) { 
    // found: ...||...&&...||...   
    ConvertLogicalEqToBitVectors(eq(0, foundORbefore-1), partResult1, 
                                 signalsInvolved1);
    ConvertLogicalEqToBitVectors(eq(foundORbefore+1, 
                                    foundORafter-foundORbefore-2),
                                 partResult2, signalsInvolved2);
    ConvertLogicalEqToBitVectors(eq(foundORafter+1, eq.Length()-foundORafter-1),
                                 partResult3, signalsInvolved3);

    // merge: 4 = 1 || 2 
    MergeResults(partResult1, partResult2, partResult4, signalsInvolved1,
                 signalsInvolved2, signalsInvolved4, kTRUE);
    // merge results = 3 || 4
    MergeResults(partResult3, partResult4, results, signalsInvolved3,
                 signalsInvolved4, signalsInvolved, kTRUE);
    return;
  } 
  else if (foundORbefore != -1) { 
    // found ...||...&&...
    ConvertLogicalEqToBitVectors(eq(0, foundORbefore - 1), partResult1, 
                                 signalsInvolved1); 
    ConvertLogicalEqToBitVectors(eq(foundORbefore+1, 
                                    eq.Length()-foundORbefore-1),
                                 partResult2, signalsInvolved2);
   
    MergeResults(partResult1, partResult2, results, signalsInvolved1,
                 signalsInvolved2, signalsInvolved, kTRUE);
    return;
  }
  else if (foundORafter != -1) {
    // found  ...&&...||...
    ConvertLogicalEqToBitVectors(eq(0, foundORafter - 1), partResult1, 
                                 signalsInvolved1); 
    ConvertLogicalEqToBitVectors(eq(foundORafter+1, 
                                    eq.Length()-foundORafter-1),
                                 partResult2, signalsInvolved2);
   
    MergeResults(partResult1, partResult2, results, signalsInvolved1,
                 signalsInvolved2, signalsInvolved, kTRUE);
    return;
  }
  else /* if (foundAND != -1)*/ { // found ...&&...
    ConvertLogicalEqToBitVectors(eq(0, foundAND-1), partResult1, 
                                 signalsInvolved1); 
    ConvertLogicalEqToBitVectors(eq(foundAND+1, eq.Length()-foundAND-1), 
                                 partResult2, signalsInvolved2); 

    MergeResults(partResult1, partResult2, results, signalsInvolved1,
                 signalsInvolved2, signalsInvolved, kFALSE);    
    return;
  }
  
  AliError("Logical equation parser error!");
  return;
}

//______________________________________________________________________________
void AliTRDptrgParam::CheckSignalsInvolved(TArrayI*& results, 
                                           TArrayI*& signalsInvolved,
                                           Int_t inputWidth) {
  // checks whether all input signals are taken into account
  //
  // this function is needed to be able to write equations which contain not all
  // possible signals and which are not mentioned in the equation do not effect
  // the result
  // X=B&&C=(A||!A)&&B&&C

  // this routine is quite inefficient but working O((2^inputWidth)^3)

  // generate mask:
  Int_t temp = 0x1;
  Int_t mask = 0x0;
  for (Int_t iSignal = 0; iSignal < inputWidth; iSignal++) {
    mask |= temp;
    temp <<= 1; // move temp to the next bit 
  }
  
  for (Int_t iResult = 0; iResult < results->GetSize(); iResult++) {
    // tricky: size of results increases while loop is iterating
    // that is needed to generate all valid input signal combinations
    if (mask != (*signalsInvolved)[iResult]) {
      // not all input signals are taken into account
      Int_t inputSignal = 0x1;
      for (Int_t iSignal = 0; iSignal < inputWidth; iSignal++) {
        if (!(inputSignal & (*signalsInvolved)[iResult])) {
          Int_t newInvolvedSignalCombination = 
            (*signalsInvolved)[iResult] | inputSignal;
          Int_t newResult = inputSignal | (*results)[iResult];
          Bool_t signalCombinationAlreadyEnlisted = kFALSE;
          for (Int_t iEntry = 0; iEntry < signalsInvolved->GetSize(); iEntry++){
            // this loop is needed to reduce the amount of equal entries in 
            // signalsInvolved
            // maybe a table with all possible input values could reduce the
            // computional effort, but this would consume a lot of ram
            if ((signalsInvolved->At(iEntry) == newInvolvedSignalCombination) &&
	        (results->At(iEntry) == newResult)) {
              signalCombinationAlreadyEnlisted = kTRUE;
              break;
	    }
          }
	  if (!signalCombinationAlreadyEnlisted) {
            results->Set(results->GetSize() + 1);
            (*results)[results->GetSize() - 1] = inputSignal | 
                                                 (*results)[iResult];
            // add variant with active bit, variant with inactive signal
            // is already containt in the results array

            // update signalsInvolved:
            signalsInvolved->Set(signalsInvolved->GetSize() + 1);
            (*signalsInvolved)[signalsInvolved->GetSize() - 1] =
              (*signalsInvolved)[iResult] | inputSignal;
	  }
	}
        inputSignal <<= 1; // move temp to the next input signal      
      }      
    }
  }
  return;
}

//______________________________________________________________________________
Int_t* AliTRDptrgParam::GenerateLUTbasedOnEq(TString eq, Int_t inputWidth, 
                                             Int_t initValue) {
  // Processes the conversion of a logical equation to a look up table
  
  TArrayI* results = 0x0;
  TArrayI* signalsInvolved = 0x0;
 
  ConvertLogicalEqToBitVectors(eq, results, signalsInvolved);
  // generate bit vectors
  
  if ((results != 0x0) && (signalsInvolved != 0x0)) {

    CheckSignalsInvolved(results, signalsInvolved, inputWidth);
    // add bit vectors for signals which are not taken into account

    Int_t lutSize =  0x1 << inputWidth; // 2^inputwidth elements
    Int_t* resultingLUT = new Int_t[lutSize]; // create LUT
    for (Int_t iLUTentry = 0; iLUTentry < lutSize; iLUTentry++) { // init LUT
      resultingLUT[iLUTentry] = 0;
    }
    for (Int_t iEntry = 0; iEntry < results->GetSize(); iEntry++) {
      resultingLUT[(*results)[iEntry]] = initValue;
    }
  
    delete results;
    results = 0x0;

    delete signalsInvolved;
    signalsInvolved = 0x0;
  
    return resultingLUT;

  }
  else {

    return 0x0;

  }

}

//______________________________________________________________________________
//___ GETTER FUNCTIONS__________________________________________________________
//______________________________________________________________________________
UInt_t* AliTRDptrgParam::GetFEBT0Thresholds(AliTRDptrgFEBPosition_t FEBposition)
  const
{
  // get T0 FEB Thresholds
  return this->fFEBT0Thresholds[FEBposition - 1];
  // 0 kB, 1= kA, 2, kC => -1 because T0FEBs are only in position kA and kC
}

//_____________________________________________________________________________
Int_t* AliTRDptrgParam::GetFEBT0LUT(AliTRDptrgFEBPosition_t FEBposition, 
                                    Int_t iLUT) {
  // get T0 FEB LUTs
  if (this->fFEBT0LUTs == 0x0) {
    this->GenerateLUTs();
  }
  return this->fFEBT0LUTs[FEBposition - 1][iLUT]; 
  // 0 kB, 1= kA, 2, kC => -1 because T0FEBs are only in position kA and kC
} 

//______________________________________________________________________________
UInt_t* AliTRDptrgParam::GetFEBV0Thresholds(AliTRDptrgFEBPosition_t FEBposition,
                                           Int_t iCard) const {
  // get V0 FEB Thresholds
  return this->fFEBV0Thresholds[FEBposition - 1][iCard];
  // 0 kB, 1= kA, 2, kC => -1 because T0FEBs are only in position kA and kC
}

//______________________________________________________________________________
Int_t* AliTRDptrgParam::GetFEBV0LUT(AliTRDptrgFEBPosition_t FEBposition, 
                                    Int_t iCard, Int_t iLUT) {
  // get V0 FEB LUTs
  if (this->fFEBV0LUTs == 0x0) {
    this->GenerateLUTs();
  }
  return this->fFEBV0LUTs[FEBposition - 1][iCard][iLUT];
  // 0 kB, 1= kA, 2, kC => -1 because T0FEBs are only in position kA and kC
}

//______________________________________________________________________________
Int_t* AliTRDptrgParam::GetCBLUT(UInt_t iCB, Int_t LUTid) {
  // return control box LUT
  // iCB: 0 = B, 1 = A, 2 = C
  if (this->fCBLUTs == 0x0) {
    this->GenerateLUTs();
  }
  return this->fCBLUTs[iCB][LUTid];
}

 AliTRDptrgParam.cxx:1
 AliTRDptrgParam.cxx:2
 AliTRDptrgParam.cxx:3
 AliTRDptrgParam.cxx:4
 AliTRDptrgParam.cxx:5
 AliTRDptrgParam.cxx:6
 AliTRDptrgParam.cxx:7
 AliTRDptrgParam.cxx:8
 AliTRDptrgParam.cxx:9
 AliTRDptrgParam.cxx:10
 AliTRDptrgParam.cxx:11
 AliTRDptrgParam.cxx:12
 AliTRDptrgParam.cxx:13
 AliTRDptrgParam.cxx:14
 AliTRDptrgParam.cxx:15
 AliTRDptrgParam.cxx:16
 AliTRDptrgParam.cxx:17
 AliTRDptrgParam.cxx:18
 AliTRDptrgParam.cxx:19
 AliTRDptrgParam.cxx:20
 AliTRDptrgParam.cxx:21
 AliTRDptrgParam.cxx:22
 AliTRDptrgParam.cxx:23
 AliTRDptrgParam.cxx:24
 AliTRDptrgParam.cxx:25
 AliTRDptrgParam.cxx:26
 AliTRDptrgParam.cxx:27
 AliTRDptrgParam.cxx:28
 AliTRDptrgParam.cxx:29
 AliTRDptrgParam.cxx:30
 AliTRDptrgParam.cxx:31
 AliTRDptrgParam.cxx:32
 AliTRDptrgParam.cxx:33
 AliTRDptrgParam.cxx:34
 AliTRDptrgParam.cxx:35
 AliTRDptrgParam.cxx:36
 AliTRDptrgParam.cxx:37
 AliTRDptrgParam.cxx:38
 AliTRDptrgParam.cxx:39
 AliTRDptrgParam.cxx:40
 AliTRDptrgParam.cxx:41
 AliTRDptrgParam.cxx:42
 AliTRDptrgParam.cxx:43
 AliTRDptrgParam.cxx:44
 AliTRDptrgParam.cxx:45
 AliTRDptrgParam.cxx:46
 AliTRDptrgParam.cxx:47
 AliTRDptrgParam.cxx:48
 AliTRDptrgParam.cxx:49
 AliTRDptrgParam.cxx:50
 AliTRDptrgParam.cxx:51
 AliTRDptrgParam.cxx:52
 AliTRDptrgParam.cxx:53
 AliTRDptrgParam.cxx:54
 AliTRDptrgParam.cxx:55
 AliTRDptrgParam.cxx:56
 AliTRDptrgParam.cxx:57
 AliTRDptrgParam.cxx:58
 AliTRDptrgParam.cxx:59
 AliTRDptrgParam.cxx:60
 AliTRDptrgParam.cxx:61
 AliTRDptrgParam.cxx:62
 AliTRDptrgParam.cxx:63
 AliTRDptrgParam.cxx:64
 AliTRDptrgParam.cxx:65
 AliTRDptrgParam.cxx:66
 AliTRDptrgParam.cxx:67
 AliTRDptrgParam.cxx:68
 AliTRDptrgParam.cxx:69
 AliTRDptrgParam.cxx:70
 AliTRDptrgParam.cxx:71
 AliTRDptrgParam.cxx:72
 AliTRDptrgParam.cxx:73
 AliTRDptrgParam.cxx:74
 AliTRDptrgParam.cxx:75
 AliTRDptrgParam.cxx:76
 AliTRDptrgParam.cxx:77
 AliTRDptrgParam.cxx:78
 AliTRDptrgParam.cxx:79
 AliTRDptrgParam.cxx:80
 AliTRDptrgParam.cxx:81
 AliTRDptrgParam.cxx:82
 AliTRDptrgParam.cxx:83
 AliTRDptrgParam.cxx:84
 AliTRDptrgParam.cxx:85
 AliTRDptrgParam.cxx:86
 AliTRDptrgParam.cxx:87
 AliTRDptrgParam.cxx:88
 AliTRDptrgParam.cxx:89
 AliTRDptrgParam.cxx:90
 AliTRDptrgParam.cxx:91
 AliTRDptrgParam.cxx:92
 AliTRDptrgParam.cxx:93
 AliTRDptrgParam.cxx:94
 AliTRDptrgParam.cxx:95
 AliTRDptrgParam.cxx:96
 AliTRDptrgParam.cxx:97
 AliTRDptrgParam.cxx:98
 AliTRDptrgParam.cxx:99
 AliTRDptrgParam.cxx:100
 AliTRDptrgParam.cxx:101
 AliTRDptrgParam.cxx:102
 AliTRDptrgParam.cxx:103
 AliTRDptrgParam.cxx:104
 AliTRDptrgParam.cxx:105
 AliTRDptrgParam.cxx:106
 AliTRDptrgParam.cxx:107
 AliTRDptrgParam.cxx:108
 AliTRDptrgParam.cxx:109
 AliTRDptrgParam.cxx:110
 AliTRDptrgParam.cxx:111
 AliTRDptrgParam.cxx:112
 AliTRDptrgParam.cxx:113
 AliTRDptrgParam.cxx:114
 AliTRDptrgParam.cxx:115
 AliTRDptrgParam.cxx:116
 AliTRDptrgParam.cxx:117
 AliTRDptrgParam.cxx:118
 AliTRDptrgParam.cxx:119
 AliTRDptrgParam.cxx:120
 AliTRDptrgParam.cxx:121
 AliTRDptrgParam.cxx:122
 AliTRDptrgParam.cxx:123
 AliTRDptrgParam.cxx:124
 AliTRDptrgParam.cxx:125
 AliTRDptrgParam.cxx:126
 AliTRDptrgParam.cxx:127
 AliTRDptrgParam.cxx:128
 AliTRDptrgParam.cxx:129
 AliTRDptrgParam.cxx:130
 AliTRDptrgParam.cxx:131
 AliTRDptrgParam.cxx:132
 AliTRDptrgParam.cxx:133
 AliTRDptrgParam.cxx:134
 AliTRDptrgParam.cxx:135
 AliTRDptrgParam.cxx:136
 AliTRDptrgParam.cxx:137
 AliTRDptrgParam.cxx:138
 AliTRDptrgParam.cxx:139
 AliTRDptrgParam.cxx:140
 AliTRDptrgParam.cxx:141
 AliTRDptrgParam.cxx:142
 AliTRDptrgParam.cxx:143
 AliTRDptrgParam.cxx:144
 AliTRDptrgParam.cxx:145
 AliTRDptrgParam.cxx:146
 AliTRDptrgParam.cxx:147
 AliTRDptrgParam.cxx:148
 AliTRDptrgParam.cxx:149
 AliTRDptrgParam.cxx:150
 AliTRDptrgParam.cxx:151
 AliTRDptrgParam.cxx:152
 AliTRDptrgParam.cxx:153
 AliTRDptrgParam.cxx:154
 AliTRDptrgParam.cxx:155
 AliTRDptrgParam.cxx:156
 AliTRDptrgParam.cxx:157
 AliTRDptrgParam.cxx:158
 AliTRDptrgParam.cxx:159
 AliTRDptrgParam.cxx:160
 AliTRDptrgParam.cxx:161
 AliTRDptrgParam.cxx:162
 AliTRDptrgParam.cxx:163
 AliTRDptrgParam.cxx:164
 AliTRDptrgParam.cxx:165
 AliTRDptrgParam.cxx:166
 AliTRDptrgParam.cxx:167
 AliTRDptrgParam.cxx:168
 AliTRDptrgParam.cxx:169
 AliTRDptrgParam.cxx:170
 AliTRDptrgParam.cxx:171
 AliTRDptrgParam.cxx:172
 AliTRDptrgParam.cxx:173
 AliTRDptrgParam.cxx:174
 AliTRDptrgParam.cxx:175
 AliTRDptrgParam.cxx:176
 AliTRDptrgParam.cxx:177
 AliTRDptrgParam.cxx:178
 AliTRDptrgParam.cxx:179
 AliTRDptrgParam.cxx:180
 AliTRDptrgParam.cxx:181
 AliTRDptrgParam.cxx:182
 AliTRDptrgParam.cxx:183
 AliTRDptrgParam.cxx:184
 AliTRDptrgParam.cxx:185
 AliTRDptrgParam.cxx:186
 AliTRDptrgParam.cxx:187
 AliTRDptrgParam.cxx:188
 AliTRDptrgParam.cxx:189
 AliTRDptrgParam.cxx:190
 AliTRDptrgParam.cxx:191
 AliTRDptrgParam.cxx:192
 AliTRDptrgParam.cxx:193
 AliTRDptrgParam.cxx:194
 AliTRDptrgParam.cxx:195
 AliTRDptrgParam.cxx:196
 AliTRDptrgParam.cxx:197
 AliTRDptrgParam.cxx:198
 AliTRDptrgParam.cxx:199
 AliTRDptrgParam.cxx:200
 AliTRDptrgParam.cxx:201
 AliTRDptrgParam.cxx:202
 AliTRDptrgParam.cxx:203
 AliTRDptrgParam.cxx:204
 AliTRDptrgParam.cxx:205
 AliTRDptrgParam.cxx:206
 AliTRDptrgParam.cxx:207
 AliTRDptrgParam.cxx:208
 AliTRDptrgParam.cxx:209
 AliTRDptrgParam.cxx:210
 AliTRDptrgParam.cxx:211
 AliTRDptrgParam.cxx:212
 AliTRDptrgParam.cxx:213
 AliTRDptrgParam.cxx:214
 AliTRDptrgParam.cxx:215
 AliTRDptrgParam.cxx:216
 AliTRDptrgParam.cxx:217
 AliTRDptrgParam.cxx:218
 AliTRDptrgParam.cxx:219
 AliTRDptrgParam.cxx:220
 AliTRDptrgParam.cxx:221
 AliTRDptrgParam.cxx:222
 AliTRDptrgParam.cxx:223
 AliTRDptrgParam.cxx:224
 AliTRDptrgParam.cxx:225
 AliTRDptrgParam.cxx:226
 AliTRDptrgParam.cxx:227
 AliTRDptrgParam.cxx:228
 AliTRDptrgParam.cxx:229
 AliTRDptrgParam.cxx:230
 AliTRDptrgParam.cxx:231
 AliTRDptrgParam.cxx:232
 AliTRDptrgParam.cxx:233
 AliTRDptrgParam.cxx:234
 AliTRDptrgParam.cxx:235
 AliTRDptrgParam.cxx:236
 AliTRDptrgParam.cxx:237
 AliTRDptrgParam.cxx:238
 AliTRDptrgParam.cxx:239
 AliTRDptrgParam.cxx:240
 AliTRDptrgParam.cxx:241
 AliTRDptrgParam.cxx:242
 AliTRDptrgParam.cxx:243
 AliTRDptrgParam.cxx:244
 AliTRDptrgParam.cxx:245
 AliTRDptrgParam.cxx:246
 AliTRDptrgParam.cxx:247
 AliTRDptrgParam.cxx:248
 AliTRDptrgParam.cxx:249
 AliTRDptrgParam.cxx:250
 AliTRDptrgParam.cxx:251
 AliTRDptrgParam.cxx:252
 AliTRDptrgParam.cxx:253
 AliTRDptrgParam.cxx:254
 AliTRDptrgParam.cxx:255
 AliTRDptrgParam.cxx:256
 AliTRDptrgParam.cxx:257
 AliTRDptrgParam.cxx:258
 AliTRDptrgParam.cxx:259
 AliTRDptrgParam.cxx:260
 AliTRDptrgParam.cxx:261
 AliTRDptrgParam.cxx:262
 AliTRDptrgParam.cxx:263
 AliTRDptrgParam.cxx:264
 AliTRDptrgParam.cxx:265
 AliTRDptrgParam.cxx:266
 AliTRDptrgParam.cxx:267
 AliTRDptrgParam.cxx:268
 AliTRDptrgParam.cxx:269
 AliTRDptrgParam.cxx:270
 AliTRDptrgParam.cxx:271
 AliTRDptrgParam.cxx:272
 AliTRDptrgParam.cxx:273
 AliTRDptrgParam.cxx:274
 AliTRDptrgParam.cxx:275
 AliTRDptrgParam.cxx:276
 AliTRDptrgParam.cxx:277
 AliTRDptrgParam.cxx:278
 AliTRDptrgParam.cxx:279
 AliTRDptrgParam.cxx:280
 AliTRDptrgParam.cxx:281
 AliTRDptrgParam.cxx:282
 AliTRDptrgParam.cxx:283
 AliTRDptrgParam.cxx:284
 AliTRDptrgParam.cxx:285
 AliTRDptrgParam.cxx:286
 AliTRDptrgParam.cxx:287
 AliTRDptrgParam.cxx:288
 AliTRDptrgParam.cxx:289
 AliTRDptrgParam.cxx:290
 AliTRDptrgParam.cxx:291
 AliTRDptrgParam.cxx:292
 AliTRDptrgParam.cxx:293
 AliTRDptrgParam.cxx:294
 AliTRDptrgParam.cxx:295
 AliTRDptrgParam.cxx:296
 AliTRDptrgParam.cxx:297
 AliTRDptrgParam.cxx:298
 AliTRDptrgParam.cxx:299
 AliTRDptrgParam.cxx:300
 AliTRDptrgParam.cxx:301
 AliTRDptrgParam.cxx:302
 AliTRDptrgParam.cxx:303
 AliTRDptrgParam.cxx:304
 AliTRDptrgParam.cxx:305
 AliTRDptrgParam.cxx:306
 AliTRDptrgParam.cxx:307
 AliTRDptrgParam.cxx:308
 AliTRDptrgParam.cxx:309
 AliTRDptrgParam.cxx:310
 AliTRDptrgParam.cxx:311
 AliTRDptrgParam.cxx:312
 AliTRDptrgParam.cxx:313
 AliTRDptrgParam.cxx:314
 AliTRDptrgParam.cxx:315
 AliTRDptrgParam.cxx:316
 AliTRDptrgParam.cxx:317
 AliTRDptrgParam.cxx:318
 AliTRDptrgParam.cxx:319
 AliTRDptrgParam.cxx:320
 AliTRDptrgParam.cxx:321
 AliTRDptrgParam.cxx:322
 AliTRDptrgParam.cxx:323
 AliTRDptrgParam.cxx:324
 AliTRDptrgParam.cxx:325
 AliTRDptrgParam.cxx:326
 AliTRDptrgParam.cxx:327
 AliTRDptrgParam.cxx:328
 AliTRDptrgParam.cxx:329
 AliTRDptrgParam.cxx:330
 AliTRDptrgParam.cxx:331
 AliTRDptrgParam.cxx:332
 AliTRDptrgParam.cxx:333
 AliTRDptrgParam.cxx:334
 AliTRDptrgParam.cxx:335
 AliTRDptrgParam.cxx:336
 AliTRDptrgParam.cxx:337
 AliTRDptrgParam.cxx:338
 AliTRDptrgParam.cxx:339
 AliTRDptrgParam.cxx:340
 AliTRDptrgParam.cxx:341
 AliTRDptrgParam.cxx:342
 AliTRDptrgParam.cxx:343
 AliTRDptrgParam.cxx:344
 AliTRDptrgParam.cxx:345
 AliTRDptrgParam.cxx:346
 AliTRDptrgParam.cxx:347
 AliTRDptrgParam.cxx:348
 AliTRDptrgParam.cxx:349
 AliTRDptrgParam.cxx:350
 AliTRDptrgParam.cxx:351
 AliTRDptrgParam.cxx:352
 AliTRDptrgParam.cxx:353
 AliTRDptrgParam.cxx:354
 AliTRDptrgParam.cxx:355
 AliTRDptrgParam.cxx:356
 AliTRDptrgParam.cxx:357
 AliTRDptrgParam.cxx:358
 AliTRDptrgParam.cxx:359
 AliTRDptrgParam.cxx:360
 AliTRDptrgParam.cxx:361
 AliTRDptrgParam.cxx:362
 AliTRDptrgParam.cxx:363
 AliTRDptrgParam.cxx:364
 AliTRDptrgParam.cxx:365
 AliTRDptrgParam.cxx:366
 AliTRDptrgParam.cxx:367
 AliTRDptrgParam.cxx:368
 AliTRDptrgParam.cxx:369
 AliTRDptrgParam.cxx:370
 AliTRDptrgParam.cxx:371
 AliTRDptrgParam.cxx:372
 AliTRDptrgParam.cxx:373
 AliTRDptrgParam.cxx:374
 AliTRDptrgParam.cxx:375
 AliTRDptrgParam.cxx:376
 AliTRDptrgParam.cxx:377
 AliTRDptrgParam.cxx:378
 AliTRDptrgParam.cxx:379
 AliTRDptrgParam.cxx:380
 AliTRDptrgParam.cxx:381
 AliTRDptrgParam.cxx:382
 AliTRDptrgParam.cxx:383
 AliTRDptrgParam.cxx:384
 AliTRDptrgParam.cxx:385
 AliTRDptrgParam.cxx:386
 AliTRDptrgParam.cxx:387
 AliTRDptrgParam.cxx:388
 AliTRDptrgParam.cxx:389
 AliTRDptrgParam.cxx:390
 AliTRDptrgParam.cxx:391
 AliTRDptrgParam.cxx:392
 AliTRDptrgParam.cxx:393
 AliTRDptrgParam.cxx:394
 AliTRDptrgParam.cxx:395
 AliTRDptrgParam.cxx:396
 AliTRDptrgParam.cxx:397
 AliTRDptrgParam.cxx:398
 AliTRDptrgParam.cxx:399
 AliTRDptrgParam.cxx:400
 AliTRDptrgParam.cxx:401
 AliTRDptrgParam.cxx:402
 AliTRDptrgParam.cxx:403
 AliTRDptrgParam.cxx:404
 AliTRDptrgParam.cxx:405
 AliTRDptrgParam.cxx:406
 AliTRDptrgParam.cxx:407
 AliTRDptrgParam.cxx:408
 AliTRDptrgParam.cxx:409
 AliTRDptrgParam.cxx:410
 AliTRDptrgParam.cxx:411
 AliTRDptrgParam.cxx:412
 AliTRDptrgParam.cxx:413
 AliTRDptrgParam.cxx:414
 AliTRDptrgParam.cxx:415
 AliTRDptrgParam.cxx:416
 AliTRDptrgParam.cxx:417
 AliTRDptrgParam.cxx:418
 AliTRDptrgParam.cxx:419
 AliTRDptrgParam.cxx:420
 AliTRDptrgParam.cxx:421
 AliTRDptrgParam.cxx:422
 AliTRDptrgParam.cxx:423
 AliTRDptrgParam.cxx:424
 AliTRDptrgParam.cxx:425
 AliTRDptrgParam.cxx:426
 AliTRDptrgParam.cxx:427
 AliTRDptrgParam.cxx:428
 AliTRDptrgParam.cxx:429
 AliTRDptrgParam.cxx:430
 AliTRDptrgParam.cxx:431
 AliTRDptrgParam.cxx:432
 AliTRDptrgParam.cxx:433
 AliTRDptrgParam.cxx:434
 AliTRDptrgParam.cxx:435
 AliTRDptrgParam.cxx:436
 AliTRDptrgParam.cxx:437
 AliTRDptrgParam.cxx:438
 AliTRDptrgParam.cxx:439
 AliTRDptrgParam.cxx:440
 AliTRDptrgParam.cxx:441
 AliTRDptrgParam.cxx:442
 AliTRDptrgParam.cxx:443
 AliTRDptrgParam.cxx:444
 AliTRDptrgParam.cxx:445
 AliTRDptrgParam.cxx:446
 AliTRDptrgParam.cxx:447
 AliTRDptrgParam.cxx:448
 AliTRDptrgParam.cxx:449
 AliTRDptrgParam.cxx:450
 AliTRDptrgParam.cxx:451
 AliTRDptrgParam.cxx:452
 AliTRDptrgParam.cxx:453
 AliTRDptrgParam.cxx:454
 AliTRDptrgParam.cxx:455
 AliTRDptrgParam.cxx:456
 AliTRDptrgParam.cxx:457
 AliTRDptrgParam.cxx:458
 AliTRDptrgParam.cxx:459
 AliTRDptrgParam.cxx:460
 AliTRDptrgParam.cxx:461
 AliTRDptrgParam.cxx:462
 AliTRDptrgParam.cxx:463
 AliTRDptrgParam.cxx:464
 AliTRDptrgParam.cxx:465
 AliTRDptrgParam.cxx:466
 AliTRDptrgParam.cxx:467
 AliTRDptrgParam.cxx:468
 AliTRDptrgParam.cxx:469
 AliTRDptrgParam.cxx:470
 AliTRDptrgParam.cxx:471
 AliTRDptrgParam.cxx:472
 AliTRDptrgParam.cxx:473
 AliTRDptrgParam.cxx:474
 AliTRDptrgParam.cxx:475
 AliTRDptrgParam.cxx:476
 AliTRDptrgParam.cxx:477
 AliTRDptrgParam.cxx:478
 AliTRDptrgParam.cxx:479
 AliTRDptrgParam.cxx:480
 AliTRDptrgParam.cxx:481
 AliTRDptrgParam.cxx:482
 AliTRDptrgParam.cxx:483
 AliTRDptrgParam.cxx:484
 AliTRDptrgParam.cxx:485
 AliTRDptrgParam.cxx:486
 AliTRDptrgParam.cxx:487
 AliTRDptrgParam.cxx:488
 AliTRDptrgParam.cxx:489
 AliTRDptrgParam.cxx:490
 AliTRDptrgParam.cxx:491
 AliTRDptrgParam.cxx:492
 AliTRDptrgParam.cxx:493
 AliTRDptrgParam.cxx:494
 AliTRDptrgParam.cxx:495
 AliTRDptrgParam.cxx:496
 AliTRDptrgParam.cxx:497
 AliTRDptrgParam.cxx:498
 AliTRDptrgParam.cxx:499
 AliTRDptrgParam.cxx:500
 AliTRDptrgParam.cxx:501
 AliTRDptrgParam.cxx:502
 AliTRDptrgParam.cxx:503
 AliTRDptrgParam.cxx:504
 AliTRDptrgParam.cxx:505
 AliTRDptrgParam.cxx:506
 AliTRDptrgParam.cxx:507
 AliTRDptrgParam.cxx:508
 AliTRDptrgParam.cxx:509
 AliTRDptrgParam.cxx:510
 AliTRDptrgParam.cxx:511
 AliTRDptrgParam.cxx:512
 AliTRDptrgParam.cxx:513
 AliTRDptrgParam.cxx:514
 AliTRDptrgParam.cxx:515
 AliTRDptrgParam.cxx:516
 AliTRDptrgParam.cxx:517
 AliTRDptrgParam.cxx:518
 AliTRDptrgParam.cxx:519
 AliTRDptrgParam.cxx:520
 AliTRDptrgParam.cxx:521
 AliTRDptrgParam.cxx:522
 AliTRDptrgParam.cxx:523
 AliTRDptrgParam.cxx:524
 AliTRDptrgParam.cxx:525
 AliTRDptrgParam.cxx:526
 AliTRDptrgParam.cxx:527
 AliTRDptrgParam.cxx:528
 AliTRDptrgParam.cxx:529
 AliTRDptrgParam.cxx:530
 AliTRDptrgParam.cxx:531
 AliTRDptrgParam.cxx:532
 AliTRDptrgParam.cxx:533
 AliTRDptrgParam.cxx:534
 AliTRDptrgParam.cxx:535
 AliTRDptrgParam.cxx:536
 AliTRDptrgParam.cxx:537
 AliTRDptrgParam.cxx:538
 AliTRDptrgParam.cxx:539
 AliTRDptrgParam.cxx:540
 AliTRDptrgParam.cxx:541
 AliTRDptrgParam.cxx:542
 AliTRDptrgParam.cxx:543
 AliTRDptrgParam.cxx:544
 AliTRDptrgParam.cxx:545
 AliTRDptrgParam.cxx:546
 AliTRDptrgParam.cxx:547
 AliTRDptrgParam.cxx:548
 AliTRDptrgParam.cxx:549
 AliTRDptrgParam.cxx:550
 AliTRDptrgParam.cxx:551
 AliTRDptrgParam.cxx:552
 AliTRDptrgParam.cxx:553
 AliTRDptrgParam.cxx:554
 AliTRDptrgParam.cxx:555
 AliTRDptrgParam.cxx:556
 AliTRDptrgParam.cxx:557
 AliTRDptrgParam.cxx:558
 AliTRDptrgParam.cxx:559
 AliTRDptrgParam.cxx:560
 AliTRDptrgParam.cxx:561
 AliTRDptrgParam.cxx:562
 AliTRDptrgParam.cxx:563
 AliTRDptrgParam.cxx:564
 AliTRDptrgParam.cxx:565
 AliTRDptrgParam.cxx:566
 AliTRDptrgParam.cxx:567
 AliTRDptrgParam.cxx:568
 AliTRDptrgParam.cxx:569
 AliTRDptrgParam.cxx:570
 AliTRDptrgParam.cxx:571
 AliTRDptrgParam.cxx:572
 AliTRDptrgParam.cxx:573
 AliTRDptrgParam.cxx:574
 AliTRDptrgParam.cxx:575
 AliTRDptrgParam.cxx:576
 AliTRDptrgParam.cxx:577
 AliTRDptrgParam.cxx:578
 AliTRDptrgParam.cxx:579
 AliTRDptrgParam.cxx:580
 AliTRDptrgParam.cxx:581
 AliTRDptrgParam.cxx:582
 AliTRDptrgParam.cxx:583
 AliTRDptrgParam.cxx:584
 AliTRDptrgParam.cxx:585
 AliTRDptrgParam.cxx:586
 AliTRDptrgParam.cxx:587
 AliTRDptrgParam.cxx:588
 AliTRDptrgParam.cxx:589
 AliTRDptrgParam.cxx:590
 AliTRDptrgParam.cxx:591
 AliTRDptrgParam.cxx:592
 AliTRDptrgParam.cxx:593
 AliTRDptrgParam.cxx:594
 AliTRDptrgParam.cxx:595
 AliTRDptrgParam.cxx:596
 AliTRDptrgParam.cxx:597
 AliTRDptrgParam.cxx:598
 AliTRDptrgParam.cxx:599
 AliTRDptrgParam.cxx:600
 AliTRDptrgParam.cxx:601
 AliTRDptrgParam.cxx:602
 AliTRDptrgParam.cxx:603
 AliTRDptrgParam.cxx:604
 AliTRDptrgParam.cxx:605
 AliTRDptrgParam.cxx:606
 AliTRDptrgParam.cxx:607
 AliTRDptrgParam.cxx:608
 AliTRDptrgParam.cxx:609
 AliTRDptrgParam.cxx:610
 AliTRDptrgParam.cxx:611
 AliTRDptrgParam.cxx:612
 AliTRDptrgParam.cxx:613
 AliTRDptrgParam.cxx:614
 AliTRDptrgParam.cxx:615
 AliTRDptrgParam.cxx:616
 AliTRDptrgParam.cxx:617
 AliTRDptrgParam.cxx:618
 AliTRDptrgParam.cxx:619
 AliTRDptrgParam.cxx:620
 AliTRDptrgParam.cxx:621
 AliTRDptrgParam.cxx:622
 AliTRDptrgParam.cxx:623
 AliTRDptrgParam.cxx:624
 AliTRDptrgParam.cxx:625
 AliTRDptrgParam.cxx:626
 AliTRDptrgParam.cxx:627
 AliTRDptrgParam.cxx:628
 AliTRDptrgParam.cxx:629
 AliTRDptrgParam.cxx:630
 AliTRDptrgParam.cxx:631
 AliTRDptrgParam.cxx:632
 AliTRDptrgParam.cxx:633
 AliTRDptrgParam.cxx:634
 AliTRDptrgParam.cxx:635
 AliTRDptrgParam.cxx:636
 AliTRDptrgParam.cxx:637
 AliTRDptrgParam.cxx:638
 AliTRDptrgParam.cxx:639
 AliTRDptrgParam.cxx:640
 AliTRDptrgParam.cxx:641
 AliTRDptrgParam.cxx:642
 AliTRDptrgParam.cxx:643
 AliTRDptrgParam.cxx:644
 AliTRDptrgParam.cxx:645
 AliTRDptrgParam.cxx:646
 AliTRDptrgParam.cxx:647
 AliTRDptrgParam.cxx:648
 AliTRDptrgParam.cxx:649
 AliTRDptrgParam.cxx:650
 AliTRDptrgParam.cxx:651
 AliTRDptrgParam.cxx:652
 AliTRDptrgParam.cxx:653
 AliTRDptrgParam.cxx:654
 AliTRDptrgParam.cxx:655
 AliTRDptrgParam.cxx:656
 AliTRDptrgParam.cxx:657
 AliTRDptrgParam.cxx:658
 AliTRDptrgParam.cxx:659
 AliTRDptrgParam.cxx:660
 AliTRDptrgParam.cxx:661
 AliTRDptrgParam.cxx:662
 AliTRDptrgParam.cxx:663
 AliTRDptrgParam.cxx:664
 AliTRDptrgParam.cxx:665
 AliTRDptrgParam.cxx:666
 AliTRDptrgParam.cxx:667
 AliTRDptrgParam.cxx:668
 AliTRDptrgParam.cxx:669
 AliTRDptrgParam.cxx:670
 AliTRDptrgParam.cxx:671
 AliTRDptrgParam.cxx:672
 AliTRDptrgParam.cxx:673
 AliTRDptrgParam.cxx:674
 AliTRDptrgParam.cxx:675
 AliTRDptrgParam.cxx:676
 AliTRDptrgParam.cxx:677
 AliTRDptrgParam.cxx:678
 AliTRDptrgParam.cxx:679
 AliTRDptrgParam.cxx:680
 AliTRDptrgParam.cxx:681
 AliTRDptrgParam.cxx:682
 AliTRDptrgParam.cxx:683
 AliTRDptrgParam.cxx:684
 AliTRDptrgParam.cxx:685
 AliTRDptrgParam.cxx:686
 AliTRDptrgParam.cxx:687
 AliTRDptrgParam.cxx:688
 AliTRDptrgParam.cxx:689
 AliTRDptrgParam.cxx:690
 AliTRDptrgParam.cxx:691
 AliTRDptrgParam.cxx:692
 AliTRDptrgParam.cxx:693
 AliTRDptrgParam.cxx:694
 AliTRDptrgParam.cxx:695
 AliTRDptrgParam.cxx:696
 AliTRDptrgParam.cxx:697
 AliTRDptrgParam.cxx:698
 AliTRDptrgParam.cxx:699
 AliTRDptrgParam.cxx:700
 AliTRDptrgParam.cxx:701
 AliTRDptrgParam.cxx:702
 AliTRDptrgParam.cxx:703
 AliTRDptrgParam.cxx:704
 AliTRDptrgParam.cxx:705
 AliTRDptrgParam.cxx:706
 AliTRDptrgParam.cxx:707
 AliTRDptrgParam.cxx:708
 AliTRDptrgParam.cxx:709
 AliTRDptrgParam.cxx:710
 AliTRDptrgParam.cxx:711
 AliTRDptrgParam.cxx:712
 AliTRDptrgParam.cxx:713
 AliTRDptrgParam.cxx:714
 AliTRDptrgParam.cxx:715
 AliTRDptrgParam.cxx:716
 AliTRDptrgParam.cxx:717
 AliTRDptrgParam.cxx:718
 AliTRDptrgParam.cxx:719
 AliTRDptrgParam.cxx:720
 AliTRDptrgParam.cxx:721
 AliTRDptrgParam.cxx:722
 AliTRDptrgParam.cxx:723
 AliTRDptrgParam.cxx:724
 AliTRDptrgParam.cxx:725
 AliTRDptrgParam.cxx:726
 AliTRDptrgParam.cxx:727
 AliTRDptrgParam.cxx:728
 AliTRDptrgParam.cxx:729
 AliTRDptrgParam.cxx:730
 AliTRDptrgParam.cxx:731
 AliTRDptrgParam.cxx:732
 AliTRDptrgParam.cxx:733
 AliTRDptrgParam.cxx:734
 AliTRDptrgParam.cxx:735
 AliTRDptrgParam.cxx:736
 AliTRDptrgParam.cxx:737
 AliTRDptrgParam.cxx:738
 AliTRDptrgParam.cxx:739
 AliTRDptrgParam.cxx:740
 AliTRDptrgParam.cxx:741
 AliTRDptrgParam.cxx:742
 AliTRDptrgParam.cxx:743
 AliTRDptrgParam.cxx:744
 AliTRDptrgParam.cxx:745
 AliTRDptrgParam.cxx:746
 AliTRDptrgParam.cxx:747
 AliTRDptrgParam.cxx:748
 AliTRDptrgParam.cxx:749
 AliTRDptrgParam.cxx:750
 AliTRDptrgParam.cxx:751
 AliTRDptrgParam.cxx:752
 AliTRDptrgParam.cxx:753
 AliTRDptrgParam.cxx:754
 AliTRDptrgParam.cxx:755
 AliTRDptrgParam.cxx:756
 AliTRDptrgParam.cxx:757
 AliTRDptrgParam.cxx:758
 AliTRDptrgParam.cxx:759
 AliTRDptrgParam.cxx:760
 AliTRDptrgParam.cxx:761
 AliTRDptrgParam.cxx:762
 AliTRDptrgParam.cxx:763
 AliTRDptrgParam.cxx:764
 AliTRDptrgParam.cxx:765
 AliTRDptrgParam.cxx:766
 AliTRDptrgParam.cxx:767
 AliTRDptrgParam.cxx:768
 AliTRDptrgParam.cxx:769
 AliTRDptrgParam.cxx:770
 AliTRDptrgParam.cxx:771
 AliTRDptrgParam.cxx:772
 AliTRDptrgParam.cxx:773
 AliTRDptrgParam.cxx:774
 AliTRDptrgParam.cxx:775
 AliTRDptrgParam.cxx:776
 AliTRDptrgParam.cxx:777
 AliTRDptrgParam.cxx:778
 AliTRDptrgParam.cxx:779
 AliTRDptrgParam.cxx:780
 AliTRDptrgParam.cxx:781
 AliTRDptrgParam.cxx:782
 AliTRDptrgParam.cxx:783
 AliTRDptrgParam.cxx:784
 AliTRDptrgParam.cxx:785
 AliTRDptrgParam.cxx:786
 AliTRDptrgParam.cxx:787
 AliTRDptrgParam.cxx:788
 AliTRDptrgParam.cxx:789
 AliTRDptrgParam.cxx:790
 AliTRDptrgParam.cxx:791
 AliTRDptrgParam.cxx:792
 AliTRDptrgParam.cxx:793
 AliTRDptrgParam.cxx:794
 AliTRDptrgParam.cxx:795
 AliTRDptrgParam.cxx:796
 AliTRDptrgParam.cxx:797
 AliTRDptrgParam.cxx:798
 AliTRDptrgParam.cxx:799
 AliTRDptrgParam.cxx:800
 AliTRDptrgParam.cxx:801
 AliTRDptrgParam.cxx:802
 AliTRDptrgParam.cxx:803
 AliTRDptrgParam.cxx:804
 AliTRDptrgParam.cxx:805
 AliTRDptrgParam.cxx:806
 AliTRDptrgParam.cxx:807
 AliTRDptrgParam.cxx:808
 AliTRDptrgParam.cxx:809
 AliTRDptrgParam.cxx:810
 AliTRDptrgParam.cxx:811
 AliTRDptrgParam.cxx:812
 AliTRDptrgParam.cxx:813
 AliTRDptrgParam.cxx:814
 AliTRDptrgParam.cxx:815
 AliTRDptrgParam.cxx:816
 AliTRDptrgParam.cxx:817
 AliTRDptrgParam.cxx:818
 AliTRDptrgParam.cxx:819
 AliTRDptrgParam.cxx:820
 AliTRDptrgParam.cxx:821
 AliTRDptrgParam.cxx:822
 AliTRDptrgParam.cxx:823
 AliTRDptrgParam.cxx:824
 AliTRDptrgParam.cxx:825
 AliTRDptrgParam.cxx:826
 AliTRDptrgParam.cxx:827
 AliTRDptrgParam.cxx:828
 AliTRDptrgParam.cxx:829
 AliTRDptrgParam.cxx:830
 AliTRDptrgParam.cxx:831
 AliTRDptrgParam.cxx:832
 AliTRDptrgParam.cxx:833
 AliTRDptrgParam.cxx:834
 AliTRDptrgParam.cxx:835
 AliTRDptrgParam.cxx:836
 AliTRDptrgParam.cxx:837
 AliTRDptrgParam.cxx:838
 AliTRDptrgParam.cxx:839
 AliTRDptrgParam.cxx:840
 AliTRDptrgParam.cxx:841
 AliTRDptrgParam.cxx:842
 AliTRDptrgParam.cxx:843
 AliTRDptrgParam.cxx:844
 AliTRDptrgParam.cxx:845
 AliTRDptrgParam.cxx:846
 AliTRDptrgParam.cxx:847
 AliTRDptrgParam.cxx:848
 AliTRDptrgParam.cxx:849
 AliTRDptrgParam.cxx:850
 AliTRDptrgParam.cxx:851
 AliTRDptrgParam.cxx:852
 AliTRDptrgParam.cxx:853
 AliTRDptrgParam.cxx:854
 AliTRDptrgParam.cxx:855
 AliTRDptrgParam.cxx:856
 AliTRDptrgParam.cxx:857
 AliTRDptrgParam.cxx:858
 AliTRDptrgParam.cxx:859
 AliTRDptrgParam.cxx:860
 AliTRDptrgParam.cxx:861
 AliTRDptrgParam.cxx:862
 AliTRDptrgParam.cxx:863
 AliTRDptrgParam.cxx:864
 AliTRDptrgParam.cxx:865
 AliTRDptrgParam.cxx:866
 AliTRDptrgParam.cxx:867
 AliTRDptrgParam.cxx:868
 AliTRDptrgParam.cxx:869
 AliTRDptrgParam.cxx:870
 AliTRDptrgParam.cxx:871
 AliTRDptrgParam.cxx:872
 AliTRDptrgParam.cxx:873
 AliTRDptrgParam.cxx:874
 AliTRDptrgParam.cxx:875
 AliTRDptrgParam.cxx:876
 AliTRDptrgParam.cxx:877
 AliTRDptrgParam.cxx:878
 AliTRDptrgParam.cxx:879
 AliTRDptrgParam.cxx:880
 AliTRDptrgParam.cxx:881
 AliTRDptrgParam.cxx:882
 AliTRDptrgParam.cxx:883
 AliTRDptrgParam.cxx:884
 AliTRDptrgParam.cxx:885
 AliTRDptrgParam.cxx:886
 AliTRDptrgParam.cxx:887
 AliTRDptrgParam.cxx:888
 AliTRDptrgParam.cxx:889
 AliTRDptrgParam.cxx:890
 AliTRDptrgParam.cxx:891
 AliTRDptrgParam.cxx:892
 AliTRDptrgParam.cxx:893
 AliTRDptrgParam.cxx:894
 AliTRDptrgParam.cxx:895
 AliTRDptrgParam.cxx:896
 AliTRDptrgParam.cxx:897
 AliTRDptrgParam.cxx:898
 AliTRDptrgParam.cxx:899
 AliTRDptrgParam.cxx:900
 AliTRDptrgParam.cxx:901
 AliTRDptrgParam.cxx:902
 AliTRDptrgParam.cxx:903
 AliTRDptrgParam.cxx:904
 AliTRDptrgParam.cxx:905
 AliTRDptrgParam.cxx:906
 AliTRDptrgParam.cxx:907
 AliTRDptrgParam.cxx:908
 AliTRDptrgParam.cxx:909
 AliTRDptrgParam.cxx:910
 AliTRDptrgParam.cxx:911
 AliTRDptrgParam.cxx:912
 AliTRDptrgParam.cxx:913
 AliTRDptrgParam.cxx:914
 AliTRDptrgParam.cxx:915
 AliTRDptrgParam.cxx:916
 AliTRDptrgParam.cxx:917
 AliTRDptrgParam.cxx:918
 AliTRDptrgParam.cxx:919
 AliTRDptrgParam.cxx:920
 AliTRDptrgParam.cxx:921
 AliTRDptrgParam.cxx:922
 AliTRDptrgParam.cxx:923
 AliTRDptrgParam.cxx:924
 AliTRDptrgParam.cxx:925
 AliTRDptrgParam.cxx:926
 AliTRDptrgParam.cxx:927
 AliTRDptrgParam.cxx:928
 AliTRDptrgParam.cxx:929
 AliTRDptrgParam.cxx:930
 AliTRDptrgParam.cxx:931
 AliTRDptrgParam.cxx:932
 AliTRDptrgParam.cxx:933
 AliTRDptrgParam.cxx:934
 AliTRDptrgParam.cxx:935
 AliTRDptrgParam.cxx:936
 AliTRDptrgParam.cxx:937
 AliTRDptrgParam.cxx:938
 AliTRDptrgParam.cxx:939
 AliTRDptrgParam.cxx:940
 AliTRDptrgParam.cxx:941
 AliTRDptrgParam.cxx:942
 AliTRDptrgParam.cxx:943
 AliTRDptrgParam.cxx:944
 AliTRDptrgParam.cxx:945
 AliTRDptrgParam.cxx:946
 AliTRDptrgParam.cxx:947
 AliTRDptrgParam.cxx:948
 AliTRDptrgParam.cxx:949
 AliTRDptrgParam.cxx:950
 AliTRDptrgParam.cxx:951
 AliTRDptrgParam.cxx:952
 AliTRDptrgParam.cxx:953
 AliTRDptrgParam.cxx:954
 AliTRDptrgParam.cxx:955
 AliTRDptrgParam.cxx:956
 AliTRDptrgParam.cxx:957
 AliTRDptrgParam.cxx:958
 AliTRDptrgParam.cxx:959
 AliTRDptrgParam.cxx:960
 AliTRDptrgParam.cxx:961
 AliTRDptrgParam.cxx:962
 AliTRDptrgParam.cxx:963
 AliTRDptrgParam.cxx:964
 AliTRDptrgParam.cxx:965
 AliTRDptrgParam.cxx:966
 AliTRDptrgParam.cxx:967
 AliTRDptrgParam.cxx:968
 AliTRDptrgParam.cxx:969
 AliTRDptrgParam.cxx:970
 AliTRDptrgParam.cxx:971
 AliTRDptrgParam.cxx:972
 AliTRDptrgParam.cxx:973
 AliTRDptrgParam.cxx:974
 AliTRDptrgParam.cxx:975
 AliTRDptrgParam.cxx:976
 AliTRDptrgParam.cxx:977
 AliTRDptrgParam.cxx:978
 AliTRDptrgParam.cxx:979
 AliTRDptrgParam.cxx:980
 AliTRDptrgParam.cxx:981
 AliTRDptrgParam.cxx:982
 AliTRDptrgParam.cxx:983
 AliTRDptrgParam.cxx:984
 AliTRDptrgParam.cxx:985
 AliTRDptrgParam.cxx:986
 AliTRDptrgParam.cxx:987
 AliTRDptrgParam.cxx:988
 AliTRDptrgParam.cxx:989
 AliTRDptrgParam.cxx:990
 AliTRDptrgParam.cxx:991
 AliTRDptrgParam.cxx:992
 AliTRDptrgParam.cxx:993
 AliTRDptrgParam.cxx:994
 AliTRDptrgParam.cxx:995
 AliTRDptrgParam.cxx:996
 AliTRDptrgParam.cxx:997
 AliTRDptrgParam.cxx:998
 AliTRDptrgParam.cxx:999
 AliTRDptrgParam.cxx:1000
 AliTRDptrgParam.cxx:1001
 AliTRDptrgParam.cxx:1002
 AliTRDptrgParam.cxx:1003
 AliTRDptrgParam.cxx:1004
 AliTRDptrgParam.cxx:1005
 AliTRDptrgParam.cxx:1006
 AliTRDptrgParam.cxx:1007
 AliTRDptrgParam.cxx:1008
 AliTRDptrgParam.cxx:1009
 AliTRDptrgParam.cxx:1010
 AliTRDptrgParam.cxx:1011
 AliTRDptrgParam.cxx:1012
 AliTRDptrgParam.cxx:1013
 AliTRDptrgParam.cxx:1014
 AliTRDptrgParam.cxx:1015
 AliTRDptrgParam.cxx:1016
 AliTRDptrgParam.cxx:1017
 AliTRDptrgParam.cxx:1018
 AliTRDptrgParam.cxx:1019
 AliTRDptrgParam.cxx:1020
 AliTRDptrgParam.cxx:1021
 AliTRDptrgParam.cxx:1022
 AliTRDptrgParam.cxx:1023
 AliTRDptrgParam.cxx:1024
 AliTRDptrgParam.cxx:1025
 AliTRDptrgParam.cxx:1026
 AliTRDptrgParam.cxx:1027
 AliTRDptrgParam.cxx:1028
 AliTRDptrgParam.cxx:1029
 AliTRDptrgParam.cxx:1030
 AliTRDptrgParam.cxx:1031
 AliTRDptrgParam.cxx:1032
 AliTRDptrgParam.cxx:1033
 AliTRDptrgParam.cxx:1034
 AliTRDptrgParam.cxx:1035
 AliTRDptrgParam.cxx:1036
 AliTRDptrgParam.cxx:1037
 AliTRDptrgParam.cxx:1038
 AliTRDptrgParam.cxx:1039
 AliTRDptrgParam.cxx:1040
 AliTRDptrgParam.cxx:1041
 AliTRDptrgParam.cxx:1042
 AliTRDptrgParam.cxx:1043
 AliTRDptrgParam.cxx:1044
 AliTRDptrgParam.cxx:1045
 AliTRDptrgParam.cxx:1046
 AliTRDptrgParam.cxx:1047
 AliTRDptrgParam.cxx:1048
 AliTRDptrgParam.cxx:1049
 AliTRDptrgParam.cxx:1050
 AliTRDptrgParam.cxx:1051
 AliTRDptrgParam.cxx:1052
 AliTRDptrgParam.cxx:1053
 AliTRDptrgParam.cxx:1054
 AliTRDptrgParam.cxx:1055
 AliTRDptrgParam.cxx:1056
 AliTRDptrgParam.cxx:1057
 AliTRDptrgParam.cxx:1058
 AliTRDptrgParam.cxx:1059
 AliTRDptrgParam.cxx:1060
 AliTRDptrgParam.cxx:1061
 AliTRDptrgParam.cxx:1062
 AliTRDptrgParam.cxx:1063
 AliTRDptrgParam.cxx:1064
 AliTRDptrgParam.cxx:1065
 AliTRDptrgParam.cxx:1066
 AliTRDptrgParam.cxx:1067
 AliTRDptrgParam.cxx:1068
 AliTRDptrgParam.cxx:1069
 AliTRDptrgParam.cxx:1070
 AliTRDptrgParam.cxx:1071
 AliTRDptrgParam.cxx:1072
 AliTRDptrgParam.cxx:1073
 AliTRDptrgParam.cxx:1074
 AliTRDptrgParam.cxx:1075
 AliTRDptrgParam.cxx:1076
 AliTRDptrgParam.cxx:1077
 AliTRDptrgParam.cxx:1078
 AliTRDptrgParam.cxx:1079
 AliTRDptrgParam.cxx:1080
 AliTRDptrgParam.cxx:1081
 AliTRDptrgParam.cxx:1082
 AliTRDptrgParam.cxx:1083
 AliTRDptrgParam.cxx:1084
 AliTRDptrgParam.cxx:1085
 AliTRDptrgParam.cxx:1086
 AliTRDptrgParam.cxx:1087
 AliTRDptrgParam.cxx:1088
 AliTRDptrgParam.cxx:1089
 AliTRDptrgParam.cxx:1090
 AliTRDptrgParam.cxx:1091
 AliTRDptrgParam.cxx:1092
 AliTRDptrgParam.cxx:1093
 AliTRDptrgParam.cxx:1094
 AliTRDptrgParam.cxx:1095
 AliTRDptrgParam.cxx:1096
 AliTRDptrgParam.cxx:1097
 AliTRDptrgParam.cxx:1098
 AliTRDptrgParam.cxx:1099
 AliTRDptrgParam.cxx:1100
 AliTRDptrgParam.cxx:1101
 AliTRDptrgParam.cxx:1102
 AliTRDptrgParam.cxx:1103
 AliTRDptrgParam.cxx:1104
 AliTRDptrgParam.cxx:1105
 AliTRDptrgParam.cxx:1106
 AliTRDptrgParam.cxx:1107
 AliTRDptrgParam.cxx:1108
 AliTRDptrgParam.cxx:1109
 AliTRDptrgParam.cxx:1110
 AliTRDptrgParam.cxx:1111
 AliTRDptrgParam.cxx:1112
 AliTRDptrgParam.cxx:1113
 AliTRDptrgParam.cxx:1114
 AliTRDptrgParam.cxx:1115
 AliTRDptrgParam.cxx:1116
 AliTRDptrgParam.cxx:1117
 AliTRDptrgParam.cxx:1118
 AliTRDptrgParam.cxx:1119
 AliTRDptrgParam.cxx:1120
 AliTRDptrgParam.cxx:1121
 AliTRDptrgParam.cxx:1122
 AliTRDptrgParam.cxx:1123
 AliTRDptrgParam.cxx:1124
 AliTRDptrgParam.cxx:1125
 AliTRDptrgParam.cxx:1126
 AliTRDptrgParam.cxx:1127
 AliTRDptrgParam.cxx:1128
 AliTRDptrgParam.cxx:1129
 AliTRDptrgParam.cxx:1130
 AliTRDptrgParam.cxx:1131
 AliTRDptrgParam.cxx:1132
 AliTRDptrgParam.cxx:1133
 AliTRDptrgParam.cxx:1134
 AliTRDptrgParam.cxx:1135
 AliTRDptrgParam.cxx:1136
 AliTRDptrgParam.cxx:1137
 AliTRDptrgParam.cxx:1138
 AliTRDptrgParam.cxx:1139
 AliTRDptrgParam.cxx:1140
 AliTRDptrgParam.cxx:1141
 AliTRDptrgParam.cxx:1142
 AliTRDptrgParam.cxx:1143
 AliTRDptrgParam.cxx:1144
 AliTRDptrgParam.cxx:1145
 AliTRDptrgParam.cxx:1146
 AliTRDptrgParam.cxx:1147
 AliTRDptrgParam.cxx:1148
 AliTRDptrgParam.cxx:1149
 AliTRDptrgParam.cxx:1150
 AliTRDptrgParam.cxx:1151
 AliTRDptrgParam.cxx:1152
 AliTRDptrgParam.cxx:1153
 AliTRDptrgParam.cxx:1154
 AliTRDptrgParam.cxx:1155
 AliTRDptrgParam.cxx:1156
 AliTRDptrgParam.cxx:1157
 AliTRDptrgParam.cxx:1158
 AliTRDptrgParam.cxx:1159
 AliTRDptrgParam.cxx:1160
 AliTRDptrgParam.cxx:1161
 AliTRDptrgParam.cxx:1162
 AliTRDptrgParam.cxx:1163
 AliTRDptrgParam.cxx:1164
 AliTRDptrgParam.cxx:1165
 AliTRDptrgParam.cxx:1166
 AliTRDptrgParam.cxx:1167
 AliTRDptrgParam.cxx:1168
 AliTRDptrgParam.cxx:1169
 AliTRDptrgParam.cxx:1170
 AliTRDptrgParam.cxx:1171
 AliTRDptrgParam.cxx:1172
 AliTRDptrgParam.cxx:1173
 AliTRDptrgParam.cxx:1174
 AliTRDptrgParam.cxx:1175
 AliTRDptrgParam.cxx:1176
 AliTRDptrgParam.cxx:1177
 AliTRDptrgParam.cxx:1178
 AliTRDptrgParam.cxx:1179
 AliTRDptrgParam.cxx:1180
 AliTRDptrgParam.cxx:1181
 AliTRDptrgParam.cxx:1182
 AliTRDptrgParam.cxx:1183
 AliTRDptrgParam.cxx:1184
 AliTRDptrgParam.cxx:1185
 AliTRDptrgParam.cxx:1186
 AliTRDptrgParam.cxx:1187
 AliTRDptrgParam.cxx:1188
 AliTRDptrgParam.cxx:1189
 AliTRDptrgParam.cxx:1190
 AliTRDptrgParam.cxx:1191
 AliTRDptrgParam.cxx:1192
 AliTRDptrgParam.cxx:1193
 AliTRDptrgParam.cxx:1194
 AliTRDptrgParam.cxx:1195
 AliTRDptrgParam.cxx:1196
 AliTRDptrgParam.cxx:1197
 AliTRDptrgParam.cxx:1198
 AliTRDptrgParam.cxx:1199
 AliTRDptrgParam.cxx:1200
 AliTRDptrgParam.cxx:1201
 AliTRDptrgParam.cxx:1202
 AliTRDptrgParam.cxx:1203
 AliTRDptrgParam.cxx:1204
 AliTRDptrgParam.cxx:1205
 AliTRDptrgParam.cxx:1206
 AliTRDptrgParam.cxx:1207
 AliTRDptrgParam.cxx:1208
 AliTRDptrgParam.cxx:1209
 AliTRDptrgParam.cxx:1210
 AliTRDptrgParam.cxx:1211
 AliTRDptrgParam.cxx:1212
 AliTRDptrgParam.cxx:1213
 AliTRDptrgParam.cxx:1214
 AliTRDptrgParam.cxx:1215
 AliTRDptrgParam.cxx:1216
 AliTRDptrgParam.cxx:1217
 AliTRDptrgParam.cxx:1218
 AliTRDptrgParam.cxx:1219
 AliTRDptrgParam.cxx:1220
 AliTRDptrgParam.cxx:1221
 AliTRDptrgParam.cxx:1222
 AliTRDptrgParam.cxx:1223
 AliTRDptrgParam.cxx:1224
 AliTRDptrgParam.cxx:1225
 AliTRDptrgParam.cxx:1226
 AliTRDptrgParam.cxx:1227
 AliTRDptrgParam.cxx:1228
 AliTRDptrgParam.cxx:1229
 AliTRDptrgParam.cxx:1230
 AliTRDptrgParam.cxx:1231
 AliTRDptrgParam.cxx:1232
 AliTRDptrgParam.cxx:1233
 AliTRDptrgParam.cxx:1234
 AliTRDptrgParam.cxx:1235
 AliTRDptrgParam.cxx:1236
 AliTRDptrgParam.cxx:1237
 AliTRDptrgParam.cxx:1238
 AliTRDptrgParam.cxx:1239
 AliTRDptrgParam.cxx:1240
 AliTRDptrgParam.cxx:1241
 AliTRDptrgParam.cxx:1242
 AliTRDptrgParam.cxx:1243
 AliTRDptrgParam.cxx:1244
 AliTRDptrgParam.cxx:1245
 AliTRDptrgParam.cxx:1246
 AliTRDptrgParam.cxx:1247
 AliTRDptrgParam.cxx:1248
 AliTRDptrgParam.cxx:1249
 AliTRDptrgParam.cxx:1250
 AliTRDptrgParam.cxx:1251
 AliTRDptrgParam.cxx:1252
 AliTRDptrgParam.cxx:1253
 AliTRDptrgParam.cxx:1254
 AliTRDptrgParam.cxx:1255
 AliTRDptrgParam.cxx:1256
 AliTRDptrgParam.cxx:1257
 AliTRDptrgParam.cxx:1258
 AliTRDptrgParam.cxx:1259
 AliTRDptrgParam.cxx:1260
 AliTRDptrgParam.cxx:1261
 AliTRDptrgParam.cxx:1262
 AliTRDptrgParam.cxx:1263
 AliTRDptrgParam.cxx:1264
 AliTRDptrgParam.cxx:1265
 AliTRDptrgParam.cxx:1266
 AliTRDptrgParam.cxx:1267
 AliTRDptrgParam.cxx:1268
 AliTRDptrgParam.cxx:1269
 AliTRDptrgParam.cxx:1270
 AliTRDptrgParam.cxx:1271
 AliTRDptrgParam.cxx:1272
 AliTRDptrgParam.cxx:1273
 AliTRDptrgParam.cxx:1274
 AliTRDptrgParam.cxx:1275
 AliTRDptrgParam.cxx:1276
 AliTRDptrgParam.cxx:1277
 AliTRDptrgParam.cxx:1278
 AliTRDptrgParam.cxx:1279
 AliTRDptrgParam.cxx:1280
 AliTRDptrgParam.cxx:1281
 AliTRDptrgParam.cxx:1282
 AliTRDptrgParam.cxx:1283
 AliTRDptrgParam.cxx:1284
 AliTRDptrgParam.cxx:1285
 AliTRDptrgParam.cxx:1286
 AliTRDptrgParam.cxx:1287
 AliTRDptrgParam.cxx:1288
 AliTRDptrgParam.cxx:1289
 AliTRDptrgParam.cxx:1290
 AliTRDptrgParam.cxx:1291
 AliTRDptrgParam.cxx:1292
 AliTRDptrgParam.cxx:1293
 AliTRDptrgParam.cxx:1294
 AliTRDptrgParam.cxx:1295
 AliTRDptrgParam.cxx:1296
 AliTRDptrgParam.cxx:1297
 AliTRDptrgParam.cxx:1298
 AliTRDptrgParam.cxx:1299
 AliTRDptrgParam.cxx:1300
 AliTRDptrgParam.cxx:1301
 AliTRDptrgParam.cxx:1302
 AliTRDptrgParam.cxx:1303
 AliTRDptrgParam.cxx:1304
 AliTRDptrgParam.cxx:1305
 AliTRDptrgParam.cxx:1306
 AliTRDptrgParam.cxx:1307
 AliTRDptrgParam.cxx:1308
 AliTRDptrgParam.cxx:1309
 AliTRDptrgParam.cxx:1310
 AliTRDptrgParam.cxx:1311
 AliTRDptrgParam.cxx:1312
 AliTRDptrgParam.cxx:1313
 AliTRDptrgParam.cxx:1314
 AliTRDptrgParam.cxx:1315
 AliTRDptrgParam.cxx:1316
 AliTRDptrgParam.cxx:1317
 AliTRDptrgParam.cxx:1318
 AliTRDptrgParam.cxx:1319
 AliTRDptrgParam.cxx:1320
 AliTRDptrgParam.cxx:1321
 AliTRDptrgParam.cxx:1322
 AliTRDptrgParam.cxx:1323
 AliTRDptrgParam.cxx:1324
 AliTRDptrgParam.cxx:1325
 AliTRDptrgParam.cxx:1326
 AliTRDptrgParam.cxx:1327
 AliTRDptrgParam.cxx:1328
 AliTRDptrgParam.cxx:1329
 AliTRDptrgParam.cxx:1330
 AliTRDptrgParam.cxx:1331
 AliTRDptrgParam.cxx:1332
 AliTRDptrgParam.cxx:1333
 AliTRDptrgParam.cxx:1334
 AliTRDptrgParam.cxx:1335
 AliTRDptrgParam.cxx:1336
 AliTRDptrgParam.cxx:1337
 AliTRDptrgParam.cxx:1338
 AliTRDptrgParam.cxx:1339
 AliTRDptrgParam.cxx:1340
 AliTRDptrgParam.cxx:1341
 AliTRDptrgParam.cxx:1342
 AliTRDptrgParam.cxx:1343
 AliTRDptrgParam.cxx:1344
 AliTRDptrgParam.cxx:1345
 AliTRDptrgParam.cxx:1346
 AliTRDptrgParam.cxx:1347
 AliTRDptrgParam.cxx:1348
 AliTRDptrgParam.cxx:1349
 AliTRDptrgParam.cxx:1350
 AliTRDptrgParam.cxx:1351
 AliTRDptrgParam.cxx:1352
 AliTRDptrgParam.cxx:1353
 AliTRDptrgParam.cxx:1354
 AliTRDptrgParam.cxx:1355
 AliTRDptrgParam.cxx:1356
 AliTRDptrgParam.cxx:1357
 AliTRDptrgParam.cxx:1358
 AliTRDptrgParam.cxx:1359
 AliTRDptrgParam.cxx:1360
 AliTRDptrgParam.cxx:1361
 AliTRDptrgParam.cxx:1362
 AliTRDptrgParam.cxx:1363
 AliTRDptrgParam.cxx:1364
 AliTRDptrgParam.cxx:1365
 AliTRDptrgParam.cxx:1366
 AliTRDptrgParam.cxx:1367
 AliTRDptrgParam.cxx:1368
 AliTRDptrgParam.cxx:1369
 AliTRDptrgParam.cxx:1370
 AliTRDptrgParam.cxx:1371
 AliTRDptrgParam.cxx:1372
 AliTRDptrgParam.cxx:1373
 AliTRDptrgParam.cxx:1374
 AliTRDptrgParam.cxx:1375
 AliTRDptrgParam.cxx:1376
 AliTRDptrgParam.cxx:1377
 AliTRDptrgParam.cxx:1378
 AliTRDptrgParam.cxx:1379
 AliTRDptrgParam.cxx:1380
 AliTRDptrgParam.cxx:1381
 AliTRDptrgParam.cxx:1382
 AliTRDptrgParam.cxx:1383
 AliTRDptrgParam.cxx:1384
 AliTRDptrgParam.cxx:1385
 AliTRDptrgParam.cxx:1386
 AliTRDptrgParam.cxx:1387
 AliTRDptrgParam.cxx:1388
 AliTRDptrgParam.cxx:1389
 AliTRDptrgParam.cxx:1390
 AliTRDptrgParam.cxx:1391
 AliTRDptrgParam.cxx:1392
 AliTRDptrgParam.cxx:1393
 AliTRDptrgParam.cxx:1394
 AliTRDptrgParam.cxx:1395
 AliTRDptrgParam.cxx:1396
 AliTRDptrgParam.cxx:1397
 AliTRDptrgParam.cxx:1398
 AliTRDptrgParam.cxx:1399
 AliTRDptrgParam.cxx:1400
 AliTRDptrgParam.cxx:1401
 AliTRDptrgParam.cxx:1402
 AliTRDptrgParam.cxx:1403
 AliTRDptrgParam.cxx:1404
 AliTRDptrgParam.cxx:1405
 AliTRDptrgParam.cxx:1406
 AliTRDptrgParam.cxx:1407
 AliTRDptrgParam.cxx:1408
 AliTRDptrgParam.cxx:1409
 AliTRDptrgParam.cxx:1410
 AliTRDptrgParam.cxx:1411
 AliTRDptrgParam.cxx:1412
 AliTRDptrgParam.cxx:1413
 AliTRDptrgParam.cxx:1414
 AliTRDptrgParam.cxx:1415
 AliTRDptrgParam.cxx:1416
 AliTRDptrgParam.cxx:1417
 AliTRDptrgParam.cxx:1418
 AliTRDptrgParam.cxx:1419
 AliTRDptrgParam.cxx:1420
 AliTRDptrgParam.cxx:1421
 AliTRDptrgParam.cxx:1422
 AliTRDptrgParam.cxx:1423
 AliTRDptrgParam.cxx:1424
 AliTRDptrgParam.cxx:1425
 AliTRDptrgParam.cxx:1426
 AliTRDptrgParam.cxx:1427
 AliTRDptrgParam.cxx:1428
 AliTRDptrgParam.cxx:1429
 AliTRDptrgParam.cxx:1430
 AliTRDptrgParam.cxx:1431
 AliTRDptrgParam.cxx:1432
 AliTRDptrgParam.cxx:1433
 AliTRDptrgParam.cxx:1434
 AliTRDptrgParam.cxx:1435
 AliTRDptrgParam.cxx:1436
 AliTRDptrgParam.cxx:1437
 AliTRDptrgParam.cxx:1438
 AliTRDptrgParam.cxx:1439
 AliTRDptrgParam.cxx:1440
 AliTRDptrgParam.cxx:1441
 AliTRDptrgParam.cxx:1442
 AliTRDptrgParam.cxx:1443
 AliTRDptrgParam.cxx:1444
 AliTRDptrgParam.cxx:1445
 AliTRDptrgParam.cxx:1446
 AliTRDptrgParam.cxx:1447
 AliTRDptrgParam.cxx:1448
 AliTRDptrgParam.cxx:1449
 AliTRDptrgParam.cxx:1450
 AliTRDptrgParam.cxx:1451
 AliTRDptrgParam.cxx:1452
 AliTRDptrgParam.cxx:1453
 AliTRDptrgParam.cxx:1454
 AliTRDptrgParam.cxx:1455
 AliTRDptrgParam.cxx:1456
 AliTRDptrgParam.cxx:1457
 AliTRDptrgParam.cxx:1458
 AliTRDptrgParam.cxx:1459
 AliTRDptrgParam.cxx:1460
 AliTRDptrgParam.cxx:1461
 AliTRDptrgParam.cxx:1462
 AliTRDptrgParam.cxx:1463
 AliTRDptrgParam.cxx:1464
 AliTRDptrgParam.cxx:1465
 AliTRDptrgParam.cxx:1466
 AliTRDptrgParam.cxx:1467
 AliTRDptrgParam.cxx:1468
 AliTRDptrgParam.cxx:1469
 AliTRDptrgParam.cxx:1470
 AliTRDptrgParam.cxx:1471
 AliTRDptrgParam.cxx:1472
 AliTRDptrgParam.cxx:1473
 AliTRDptrgParam.cxx:1474
 AliTRDptrgParam.cxx:1475
 AliTRDptrgParam.cxx:1476
 AliTRDptrgParam.cxx:1477
 AliTRDptrgParam.cxx:1478
 AliTRDptrgParam.cxx:1479
 AliTRDptrgParam.cxx:1480
 AliTRDptrgParam.cxx:1481
 AliTRDptrgParam.cxx:1482
 AliTRDptrgParam.cxx:1483
 AliTRDptrgParam.cxx:1484
 AliTRDptrgParam.cxx:1485
 AliTRDptrgParam.cxx:1486
 AliTRDptrgParam.cxx:1487
 AliTRDptrgParam.cxx:1488
 AliTRDptrgParam.cxx:1489
 AliTRDptrgParam.cxx:1490
 AliTRDptrgParam.cxx:1491
 AliTRDptrgParam.cxx:1492
 AliTRDptrgParam.cxx:1493
 AliTRDptrgParam.cxx:1494
 AliTRDptrgParam.cxx:1495
 AliTRDptrgParam.cxx:1496
 AliTRDptrgParam.cxx:1497
 AliTRDptrgParam.cxx:1498
 AliTRDptrgParam.cxx:1499
 AliTRDptrgParam.cxx:1500
 AliTRDptrgParam.cxx:1501
 AliTRDptrgParam.cxx:1502
 AliTRDptrgParam.cxx:1503
 AliTRDptrgParam.cxx:1504
 AliTRDptrgParam.cxx:1505
 AliTRDptrgParam.cxx:1506
 AliTRDptrgParam.cxx:1507
 AliTRDptrgParam.cxx:1508
 AliTRDptrgParam.cxx:1509
 AliTRDptrgParam.cxx:1510
 AliTRDptrgParam.cxx:1511
 AliTRDptrgParam.cxx:1512
 AliTRDptrgParam.cxx:1513
 AliTRDptrgParam.cxx:1514
 AliTRDptrgParam.cxx:1515
 AliTRDptrgParam.cxx:1516
 AliTRDptrgParam.cxx:1517
 AliTRDptrgParam.cxx:1518
 AliTRDptrgParam.cxx:1519
 AliTRDptrgParam.cxx:1520
 AliTRDptrgParam.cxx:1521
 AliTRDptrgParam.cxx:1522
 AliTRDptrgParam.cxx:1523
 AliTRDptrgParam.cxx:1524
 AliTRDptrgParam.cxx:1525
 AliTRDptrgParam.cxx:1526
 AliTRDptrgParam.cxx:1527
 AliTRDptrgParam.cxx:1528
 AliTRDptrgParam.cxx:1529
 AliTRDptrgParam.cxx:1530
 AliTRDptrgParam.cxx:1531
 AliTRDptrgParam.cxx:1532
 AliTRDptrgParam.cxx:1533
 AliTRDptrgParam.cxx:1534
 AliTRDptrgParam.cxx:1535
 AliTRDptrgParam.cxx:1536
 AliTRDptrgParam.cxx:1537
 AliTRDptrgParam.cxx:1538
 AliTRDptrgParam.cxx:1539
 AliTRDptrgParam.cxx:1540
 AliTRDptrgParam.cxx:1541
 AliTRDptrgParam.cxx:1542
 AliTRDptrgParam.cxx:1543
 AliTRDptrgParam.cxx:1544
 AliTRDptrgParam.cxx:1545
 AliTRDptrgParam.cxx:1546
 AliTRDptrgParam.cxx:1547
 AliTRDptrgParam.cxx:1548
 AliTRDptrgParam.cxx:1549
 AliTRDptrgParam.cxx:1550
 AliTRDptrgParam.cxx:1551
 AliTRDptrgParam.cxx:1552
 AliTRDptrgParam.cxx:1553
 AliTRDptrgParam.cxx:1554
 AliTRDptrgParam.cxx:1555
 AliTRDptrgParam.cxx:1556
 AliTRDptrgParam.cxx:1557
 AliTRDptrgParam.cxx:1558
 AliTRDptrgParam.cxx:1559
 AliTRDptrgParam.cxx:1560
 AliTRDptrgParam.cxx:1561
 AliTRDptrgParam.cxx:1562
 AliTRDptrgParam.cxx:1563
 AliTRDptrgParam.cxx:1564
 AliTRDptrgParam.cxx:1565
 AliTRDptrgParam.cxx:1566
 AliTRDptrgParam.cxx:1567
 AliTRDptrgParam.cxx:1568
 AliTRDptrgParam.cxx:1569
 AliTRDptrgParam.cxx:1570
 AliTRDptrgParam.cxx:1571
 AliTRDptrgParam.cxx:1572
 AliTRDptrgParam.cxx:1573
 AliTRDptrgParam.cxx:1574
 AliTRDptrgParam.cxx:1575
 AliTRDptrgParam.cxx:1576
 AliTRDptrgParam.cxx:1577
 AliTRDptrgParam.cxx:1578
 AliTRDptrgParam.cxx:1579
 AliTRDptrgParam.cxx:1580
 AliTRDptrgParam.cxx:1581
 AliTRDptrgParam.cxx:1582
 AliTRDptrgParam.cxx:1583
 AliTRDptrgParam.cxx:1584
 AliTRDptrgParam.cxx:1585
 AliTRDptrgParam.cxx:1586
 AliTRDptrgParam.cxx:1587
 AliTRDptrgParam.cxx:1588
 AliTRDptrgParam.cxx:1589
 AliTRDptrgParam.cxx:1590
 AliTRDptrgParam.cxx:1591
 AliTRDptrgParam.cxx:1592
 AliTRDptrgParam.cxx:1593
 AliTRDptrgParam.cxx:1594
 AliTRDptrgParam.cxx:1595
 AliTRDptrgParam.cxx:1596
 AliTRDptrgParam.cxx:1597
 AliTRDptrgParam.cxx:1598
 AliTRDptrgParam.cxx:1599
 AliTRDptrgParam.cxx:1600
 AliTRDptrgParam.cxx:1601
 AliTRDptrgParam.cxx:1602
 AliTRDptrgParam.cxx:1603
 AliTRDptrgParam.cxx:1604
 AliTRDptrgParam.cxx:1605
 AliTRDptrgParam.cxx:1606
 AliTRDptrgParam.cxx:1607
 AliTRDptrgParam.cxx:1608
 AliTRDptrgParam.cxx:1609
 AliTRDptrgParam.cxx:1610
 AliTRDptrgParam.cxx:1611
 AliTRDptrgParam.cxx:1612
 AliTRDptrgParam.cxx:1613
 AliTRDptrgParam.cxx:1614
 AliTRDptrgParam.cxx:1615
 AliTRDptrgParam.cxx:1616
 AliTRDptrgParam.cxx:1617
 AliTRDptrgParam.cxx:1618
 AliTRDptrgParam.cxx:1619
 AliTRDptrgParam.cxx:1620
 AliTRDptrgParam.cxx:1621
 AliTRDptrgParam.cxx:1622
 AliTRDptrgParam.cxx:1623
 AliTRDptrgParam.cxx:1624
 AliTRDptrgParam.cxx:1625
 AliTRDptrgParam.cxx:1626
 AliTRDptrgParam.cxx:1627
 AliTRDptrgParam.cxx:1628
 AliTRDptrgParam.cxx:1629
 AliTRDptrgParam.cxx:1630
 AliTRDptrgParam.cxx:1631
 AliTRDptrgParam.cxx:1632
 AliTRDptrgParam.cxx:1633
 AliTRDptrgParam.cxx:1634
 AliTRDptrgParam.cxx:1635
 AliTRDptrgParam.cxx:1636
 AliTRDptrgParam.cxx:1637
 AliTRDptrgParam.cxx:1638
 AliTRDptrgParam.cxx:1639
 AliTRDptrgParam.cxx:1640
 AliTRDptrgParam.cxx:1641
 AliTRDptrgParam.cxx:1642
 AliTRDptrgParam.cxx:1643
 AliTRDptrgParam.cxx:1644
 AliTRDptrgParam.cxx:1645
 AliTRDptrgParam.cxx:1646
 AliTRDptrgParam.cxx:1647
 AliTRDptrgParam.cxx:1648
 AliTRDptrgParam.cxx:1649
 AliTRDptrgParam.cxx:1650
 AliTRDptrgParam.cxx:1651
 AliTRDptrgParam.cxx:1652
 AliTRDptrgParam.cxx:1653
 AliTRDptrgParam.cxx:1654
 AliTRDptrgParam.cxx:1655
 AliTRDptrgParam.cxx:1656
 AliTRDptrgParam.cxx:1657
 AliTRDptrgParam.cxx:1658
 AliTRDptrgParam.cxx:1659
 AliTRDptrgParam.cxx:1660
 AliTRDptrgParam.cxx:1661
 AliTRDptrgParam.cxx:1662
 AliTRDptrgParam.cxx:1663
 AliTRDptrgParam.cxx:1664
 AliTRDptrgParam.cxx:1665
 AliTRDptrgParam.cxx:1666
 AliTRDptrgParam.cxx:1667
 AliTRDptrgParam.cxx:1668
 AliTRDptrgParam.cxx:1669
 AliTRDptrgParam.cxx:1670
 AliTRDptrgParam.cxx:1671
 AliTRDptrgParam.cxx:1672
 AliTRDptrgParam.cxx:1673
 AliTRDptrgParam.cxx:1674
 AliTRDptrgParam.cxx:1675
 AliTRDptrgParam.cxx:1676
 AliTRDptrgParam.cxx:1677
 AliTRDptrgParam.cxx:1678
 AliTRDptrgParam.cxx:1679
 AliTRDptrgParam.cxx:1680
 AliTRDptrgParam.cxx:1681
 AliTRDptrgParam.cxx:1682
 AliTRDptrgParam.cxx:1683
 AliTRDptrgParam.cxx:1684
 AliTRDptrgParam.cxx:1685
 AliTRDptrgParam.cxx:1686
 AliTRDptrgParam.cxx:1687
 AliTRDptrgParam.cxx:1688
 AliTRDptrgParam.cxx:1689
 AliTRDptrgParam.cxx:1690
 AliTRDptrgParam.cxx:1691
 AliTRDptrgParam.cxx:1692
 AliTRDptrgParam.cxx:1693
 AliTRDptrgParam.cxx:1694
 AliTRDptrgParam.cxx:1695
 AliTRDptrgParam.cxx:1696
 AliTRDptrgParam.cxx:1697
 AliTRDptrgParam.cxx:1698
 AliTRDptrgParam.cxx:1699
 AliTRDptrgParam.cxx:1700
 AliTRDptrgParam.cxx:1701
 AliTRDptrgParam.cxx:1702
 AliTRDptrgParam.cxx:1703
 AliTRDptrgParam.cxx:1704
 AliTRDptrgParam.cxx:1705
 AliTRDptrgParam.cxx:1706
 AliTRDptrgParam.cxx:1707
 AliTRDptrgParam.cxx:1708
 AliTRDptrgParam.cxx:1709
 AliTRDptrgParam.cxx:1710
 AliTRDptrgParam.cxx:1711
 AliTRDptrgParam.cxx:1712
 AliTRDptrgParam.cxx:1713
 AliTRDptrgParam.cxx:1714
 AliTRDptrgParam.cxx:1715
 AliTRDptrgParam.cxx:1716
 AliTRDptrgParam.cxx:1717
 AliTRDptrgParam.cxx:1718
 AliTRDptrgParam.cxx:1719
 AliTRDptrgParam.cxx:1720
 AliTRDptrgParam.cxx:1721
 AliTRDptrgParam.cxx:1722
 AliTRDptrgParam.cxx:1723
 AliTRDptrgParam.cxx:1724
 AliTRDptrgParam.cxx:1725
 AliTRDptrgParam.cxx:1726
 AliTRDptrgParam.cxx:1727
 AliTRDptrgParam.cxx:1728
 AliTRDptrgParam.cxx:1729
 AliTRDptrgParam.cxx:1730
 AliTRDptrgParam.cxx:1731
 AliTRDptrgParam.cxx:1732
 AliTRDptrgParam.cxx:1733
 AliTRDptrgParam.cxx:1734
 AliTRDptrgParam.cxx:1735
 AliTRDptrgParam.cxx:1736
 AliTRDptrgParam.cxx:1737
 AliTRDptrgParam.cxx:1738
 AliTRDptrgParam.cxx:1739
 AliTRDptrgParam.cxx:1740
 AliTRDptrgParam.cxx:1741
 AliTRDptrgParam.cxx:1742
 AliTRDptrgParam.cxx:1743
 AliTRDptrgParam.cxx:1744
 AliTRDptrgParam.cxx:1745
 AliTRDptrgParam.cxx:1746
 AliTRDptrgParam.cxx:1747
 AliTRDptrgParam.cxx:1748
 AliTRDptrgParam.cxx:1749
 AliTRDptrgParam.cxx:1750
 AliTRDptrgParam.cxx:1751
 AliTRDptrgParam.cxx:1752
 AliTRDptrgParam.cxx:1753
 AliTRDptrgParam.cxx:1754
 AliTRDptrgParam.cxx:1755
 AliTRDptrgParam.cxx:1756
 AliTRDptrgParam.cxx:1757
 AliTRDptrgParam.cxx:1758
 AliTRDptrgParam.cxx:1759
 AliTRDptrgParam.cxx:1760
 AliTRDptrgParam.cxx:1761
 AliTRDptrgParam.cxx:1762
 AliTRDptrgParam.cxx:1763
 AliTRDptrgParam.cxx:1764
 AliTRDptrgParam.cxx:1765
 AliTRDptrgParam.cxx:1766
 AliTRDptrgParam.cxx:1767
 AliTRDptrgParam.cxx:1768
 AliTRDptrgParam.cxx:1769
 AliTRDptrgParam.cxx:1770
 AliTRDptrgParam.cxx:1771
 AliTRDptrgParam.cxx:1772
 AliTRDptrgParam.cxx:1773
 AliTRDptrgParam.cxx:1774
 AliTRDptrgParam.cxx:1775
 AliTRDptrgParam.cxx:1776
 AliTRDptrgParam.cxx:1777
 AliTRDptrgParam.cxx:1778
 AliTRDptrgParam.cxx:1779
 AliTRDptrgParam.cxx:1780
 AliTRDptrgParam.cxx:1781
 AliTRDptrgParam.cxx:1782
 AliTRDptrgParam.cxx:1783
 AliTRDptrgParam.cxx:1784
 AliTRDptrgParam.cxx:1785
 AliTRDptrgParam.cxx:1786
 AliTRDptrgParam.cxx:1787
 AliTRDptrgParam.cxx:1788
 AliTRDptrgParam.cxx:1789
 AliTRDptrgParam.cxx:1790
 AliTRDptrgParam.cxx:1791
 AliTRDptrgParam.cxx:1792
 AliTRDptrgParam.cxx:1793
 AliTRDptrgParam.cxx:1794
 AliTRDptrgParam.cxx:1795
 AliTRDptrgParam.cxx:1796
 AliTRDptrgParam.cxx:1797
 AliTRDptrgParam.cxx:1798
 AliTRDptrgParam.cxx:1799
 AliTRDptrgParam.cxx:1800
 AliTRDptrgParam.cxx:1801
 AliTRDptrgParam.cxx:1802
 AliTRDptrgParam.cxx:1803
 AliTRDptrgParam.cxx:1804
 AliTRDptrgParam.cxx:1805
 AliTRDptrgParam.cxx:1806
 AliTRDptrgParam.cxx:1807
 AliTRDptrgParam.cxx:1808
 AliTRDptrgParam.cxx:1809
 AliTRDptrgParam.cxx:1810
 AliTRDptrgParam.cxx:1811
 AliTRDptrgParam.cxx:1812
 AliTRDptrgParam.cxx:1813
 AliTRDptrgParam.cxx:1814
 AliTRDptrgParam.cxx:1815
 AliTRDptrgParam.cxx:1816
 AliTRDptrgParam.cxx:1817
 AliTRDptrgParam.cxx:1818
 AliTRDptrgParam.cxx:1819
 AliTRDptrgParam.cxx:1820
 AliTRDptrgParam.cxx:1821
 AliTRDptrgParam.cxx:1822
 AliTRDptrgParam.cxx:1823
 AliTRDptrgParam.cxx:1824
 AliTRDptrgParam.cxx:1825
 AliTRDptrgParam.cxx:1826
 AliTRDptrgParam.cxx:1827
 AliTRDptrgParam.cxx:1828
 AliTRDptrgParam.cxx:1829
 AliTRDptrgParam.cxx:1830
 AliTRDptrgParam.cxx:1831
 AliTRDptrgParam.cxx:1832
 AliTRDptrgParam.cxx:1833
 AliTRDptrgParam.cxx:1834
 AliTRDptrgParam.cxx:1835
 AliTRDptrgParam.cxx:1836
 AliTRDptrgParam.cxx:1837
 AliTRDptrgParam.cxx:1838
 AliTRDptrgParam.cxx:1839
 AliTRDptrgParam.cxx:1840
 AliTRDptrgParam.cxx:1841
 AliTRDptrgParam.cxx:1842
 AliTRDptrgParam.cxx:1843
 AliTRDptrgParam.cxx:1844
 AliTRDptrgParam.cxx:1845
 AliTRDptrgParam.cxx:1846
 AliTRDptrgParam.cxx:1847
 AliTRDptrgParam.cxx:1848
 AliTRDptrgParam.cxx:1849
 AliTRDptrgParam.cxx:1850
 AliTRDptrgParam.cxx:1851
 AliTRDptrgParam.cxx:1852
 AliTRDptrgParam.cxx:1853
 AliTRDptrgParam.cxx:1854
 AliTRDptrgParam.cxx:1855
 AliTRDptrgParam.cxx:1856
 AliTRDptrgParam.cxx:1857
 AliTRDptrgParam.cxx:1858
 AliTRDptrgParam.cxx:1859
 AliTRDptrgParam.cxx:1860
 AliTRDptrgParam.cxx:1861
 AliTRDptrgParam.cxx:1862
 AliTRDptrgParam.cxx:1863
 AliTRDptrgParam.cxx:1864
 AliTRDptrgParam.cxx:1865
 AliTRDptrgParam.cxx:1866
 AliTRDptrgParam.cxx:1867
 AliTRDptrgParam.cxx:1868
 AliTRDptrgParam.cxx:1869
 AliTRDptrgParam.cxx:1870
 AliTRDptrgParam.cxx:1871
 AliTRDptrgParam.cxx:1872
 AliTRDptrgParam.cxx:1873
 AliTRDptrgParam.cxx:1874
 AliTRDptrgParam.cxx:1875
 AliTRDptrgParam.cxx:1876
 AliTRDptrgParam.cxx:1877
 AliTRDptrgParam.cxx:1878
 AliTRDptrgParam.cxx:1879
 AliTRDptrgParam.cxx:1880
 AliTRDptrgParam.cxx:1881
 AliTRDptrgParam.cxx:1882
 AliTRDptrgParam.cxx:1883
 AliTRDptrgParam.cxx:1884
 AliTRDptrgParam.cxx:1885
 AliTRDptrgParam.cxx:1886
 AliTRDptrgParam.cxx:1887
 AliTRDptrgParam.cxx:1888
 AliTRDptrgParam.cxx:1889
 AliTRDptrgParam.cxx:1890
 AliTRDptrgParam.cxx:1891
 AliTRDptrgParam.cxx:1892
 AliTRDptrgParam.cxx:1893
 AliTRDptrgParam.cxx:1894
 AliTRDptrgParam.cxx:1895
 AliTRDptrgParam.cxx:1896
 AliTRDptrgParam.cxx:1897
 AliTRDptrgParam.cxx:1898
 AliTRDptrgParam.cxx:1899
 AliTRDptrgParam.cxx:1900
 AliTRDptrgParam.cxx:1901
 AliTRDptrgParam.cxx:1902
 AliTRDptrgParam.cxx:1903
 AliTRDptrgParam.cxx:1904
 AliTRDptrgParam.cxx:1905
 AliTRDptrgParam.cxx:1906
 AliTRDptrgParam.cxx:1907
 AliTRDptrgParam.cxx:1908
 AliTRDptrgParam.cxx:1909
 AliTRDptrgParam.cxx:1910
 AliTRDptrgParam.cxx:1911
 AliTRDptrgParam.cxx:1912
 AliTRDptrgParam.cxx:1913
 AliTRDptrgParam.cxx:1914
 AliTRDptrgParam.cxx:1915
 AliTRDptrgParam.cxx:1916
 AliTRDptrgParam.cxx:1917
 AliTRDptrgParam.cxx:1918
 AliTRDptrgParam.cxx:1919
 AliTRDptrgParam.cxx:1920
 AliTRDptrgParam.cxx:1921
 AliTRDptrgParam.cxx:1922
 AliTRDptrgParam.cxx:1923
 AliTRDptrgParam.cxx:1924
 AliTRDptrgParam.cxx:1925
 AliTRDptrgParam.cxx:1926
 AliTRDptrgParam.cxx:1927
 AliTRDptrgParam.cxx:1928
 AliTRDptrgParam.cxx:1929
 AliTRDptrgParam.cxx:1930
 AliTRDptrgParam.cxx:1931
 AliTRDptrgParam.cxx:1932
 AliTRDptrgParam.cxx:1933
 AliTRDptrgParam.cxx:1934
 AliTRDptrgParam.cxx:1935
 AliTRDptrgParam.cxx:1936
 AliTRDptrgParam.cxx:1937
 AliTRDptrgParam.cxx:1938
 AliTRDptrgParam.cxx:1939
 AliTRDptrgParam.cxx:1940
 AliTRDptrgParam.cxx:1941
 AliTRDptrgParam.cxx:1942
 AliTRDptrgParam.cxx:1943
 AliTRDptrgParam.cxx:1944
 AliTRDptrgParam.cxx:1945
 AliTRDptrgParam.cxx:1946
 AliTRDptrgParam.cxx:1947
 AliTRDptrgParam.cxx:1948
 AliTRDptrgParam.cxx:1949
 AliTRDptrgParam.cxx:1950
 AliTRDptrgParam.cxx:1951
 AliTRDptrgParam.cxx:1952
 AliTRDptrgParam.cxx:1953
 AliTRDptrgParam.cxx:1954
 AliTRDptrgParam.cxx:1955
 AliTRDptrgParam.cxx:1956
 AliTRDptrgParam.cxx:1957
 AliTRDptrgParam.cxx:1958
 AliTRDptrgParam.cxx:1959
 AliTRDptrgParam.cxx:1960
 AliTRDptrgParam.cxx:1961
 AliTRDptrgParam.cxx:1962
 AliTRDptrgParam.cxx:1963
 AliTRDptrgParam.cxx:1964
 AliTRDptrgParam.cxx:1965
 AliTRDptrgParam.cxx:1966
 AliTRDptrgParam.cxx:1967
 AliTRDptrgParam.cxx:1968
 AliTRDptrgParam.cxx:1969
 AliTRDptrgParam.cxx:1970
 AliTRDptrgParam.cxx:1971
 AliTRDptrgParam.cxx:1972
 AliTRDptrgParam.cxx:1973
 AliTRDptrgParam.cxx:1974
 AliTRDptrgParam.cxx:1975
 AliTRDptrgParam.cxx:1976
 AliTRDptrgParam.cxx:1977
 AliTRDptrgParam.cxx:1978
 AliTRDptrgParam.cxx:1979
 AliTRDptrgParam.cxx:1980
 AliTRDptrgParam.cxx:1981
 AliTRDptrgParam.cxx:1982
 AliTRDptrgParam.cxx:1983
 AliTRDptrgParam.cxx:1984
 AliTRDptrgParam.cxx:1985
 AliTRDptrgParam.cxx:1986
 AliTRDptrgParam.cxx:1987
 AliTRDptrgParam.cxx:1988
 AliTRDptrgParam.cxx:1989
 AliTRDptrgParam.cxx:1990
 AliTRDptrgParam.cxx:1991