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.                  *
 **************************************************************************/

//-----------------------------------------------------------------
//           Implementation of the TPC PID class
// Very naive one... Should be made better by the detector experts...
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
// With many additions and modifications suggested by
//      Alexander Kalweit, GSI, alexander.philipp.kalweit@cern.ch
//      Dariusz Miskowiec, GSI, D.Miskowiec@gsi.de
// ...and some modifications by
//      Mikolaj Krzewicki, GSI, mikolaj.krzewicki@cern.ch
// ...and some modifications plus eta correction functions by
//      Benjamin Hess, University of Tuebingen, bhess@cern.ch
//-----------------------------------------------------------------

#include <TGraph.h>
#include <TObjArray.h>
#include <TSpline.h>
#include <TBits.h>
#include <TMath.h>
#include <TH2D.h>

#include <AliLog.h>
#include "AliExternalTrackParam.h"
#include "AliVTrack.h"
#include "AliTPCPIDResponse.h"
#include "AliTPCdEdxInfo.h"
#include "TFile.h"
#include "TSpline.h"

ClassImp(AliTPCPIDResponse);


AliTPCPIDResponse *AliTPCPIDResponse::fgInstance =0;

const char* AliTPCPIDResponse::fgkGainScenarioName[fgkNumberOfGainScenarios+1]=
{
  "", //default - no name
  "1", //all high
  "2", //OROC only
  "unknown"
};

//_________________________________________________________________________
AliTPCPIDResponse::AliTPCPIDResponse():
  TNamed(),
  fMIP(50.),
  fRes0(),
  fResN2(),
  fKp1(0.0283086),
  fKp2(2.63394e+01),
  fKp3(5.04114e-11),
  fKp4(2.12543),
  fKp5(4.88663),
  fUseDatabase(kFALSE),
  fResponseFunctions(fgkNumberOfParticleSpecies*fgkNumberOfGainScenarios),
  fVoltageMap(72),
  fLowGainIROCthreshold(-40),
  fBadIROCthreshhold(-70),
  fLowGainOROCthreshold(-40),
  fBadOROCthreshhold(-40),
  fMaxBadLengthFraction(0.5),
  fMagField(0.),
  fhEtaCorr(0x0),
  fhEtaSigmaPar1(0x0),
  fSigmaPar0(0.0),
  fCurrentEventMultiplicity(0),
  fCorrFuncMultiplicity(0x0),
  fCorrFuncMultiplicityTanTheta(0x0),
  fCorrFuncSigmaMultiplicity(0x0),
  fSplineArray()
{
  //
  //  The default constructor
  //
  
  AliLog::SetClassDebugLevel("AliTPCPIDResponse", AliLog::kInfo); 
  
  for (Int_t i=0; i<fgkNumberOfGainScenarios; i++) {fRes0[i]=0.07;fResN2[i]=0.0;}
  
  fCorrFuncMultiplicity = new TF1("fCorrFuncMultiplicity", 
                                  "[0] + [1]*TMath::Max([4], TMath::Min(x, [3])) + [2] * TMath::Power(TMath::Max([4], TMath::Min(x, [3])), 2)",
                                  0., 0.2);
  fCorrFuncMultiplicityTanTheta = new TF1("fCorrFuncMultiplicityTanTheta", "[0] * (x - [2]) + [1] * (x * x - [2] * [2])", -1.5, 1.5);
  fCorrFuncSigmaMultiplicity = new TF1("fCorrFuncSigmaMultiplicity",
                                       "TMath::Max(0, [0] + [1]*TMath::Min(x, [3]) + [2] * TMath::Power(TMath::Min(x, [3]), 2))", 0., 0.2);

  
  ResetMultiplicityCorrectionFunctions();
  fgInstance=this;
}
/*TODO remove?
//_________________________________________________________________________
AliTPCPIDResponse::AliTPCPIDResponse(const Double_t *param):
  TNamed(),
  fMIP(param[0]),
  fRes0(),
  fResN2(),
  fKp1(0.0283086),
  fKp2(2.63394e+01),
  fKp3(5.04114e-11),
  fKp4(2.12543),
  fKp5(4.88663),
  fUseDatabase(kFALSE),
  fResponseFunctions(fgkNumberOfParticleSpecies*fgkNumberOfGainScenarios),
  fVoltageMap(72),
  fLowGainIROCthreshold(-40),
  fBadIROCthreshhold(-70),
  fLowGainOROCthreshold(-40),
  fBadOROCthreshhold(-40),
  fMaxBadLengthFraction(0.5),
  fMagField(0.),
  fhEtaCorr(0x0),
  fhEtaSigmaPar1(0x0),
  fSigmaPar0(0.0)
{
  //
  //  The main constructor
  //
  for (Int_t i=0; i<fgkNumberOfGainScenarios; i++) {fRes0[i]=param[1];fResN2[i]=param[2];}
}
*/

//_________________________________________________________________________
AliTPCPIDResponse::~AliTPCPIDResponse()
{
  //
  // Destructor
  //
  
  delete fhEtaCorr;
  fhEtaCorr = 0x0;
  
  delete fhEtaSigmaPar1;
  fhEtaSigmaPar1 = 0x0;
  
  delete fCorrFuncMultiplicity;
  fCorrFuncMultiplicity = 0x0;
  
  delete fCorrFuncMultiplicityTanTheta;
  fCorrFuncMultiplicityTanTheta = 0x0;
  
  delete fCorrFuncSigmaMultiplicity;
  fCorrFuncSigmaMultiplicity = 0x0;
  if (fgInstance==this) fgInstance=0;
}


//_________________________________________________________________________
AliTPCPIDResponse::AliTPCPIDResponse(const AliTPCPIDResponse& that):
  TNamed(that),
  fMIP(that.fMIP),
  fRes0(),
  fResN2(),
  fKp1(that.fKp1),
  fKp2(that.fKp2),
  fKp3(that.fKp3),
  fKp4(that.fKp4),
  fKp5(that.fKp5),
  fUseDatabase(that.fUseDatabase),
  fResponseFunctions(that.fResponseFunctions),
  fVoltageMap(that.fVoltageMap),
  fLowGainIROCthreshold(that.fLowGainIROCthreshold),
  fBadIROCthreshhold(that.fBadIROCthreshhold),
  fLowGainOROCthreshold(that.fLowGainOROCthreshold),
  fBadOROCthreshhold(that.fBadOROCthreshhold),
  fMaxBadLengthFraction(that.fMaxBadLengthFraction),
  fMagField(that.fMagField),
  fhEtaCorr(0x0),
  fhEtaSigmaPar1(0x0),
  fSigmaPar0(that.fSigmaPar0),
  fCurrentEventMultiplicity(that.fCurrentEventMultiplicity),
  fCorrFuncMultiplicity(0x0),
  fCorrFuncMultiplicityTanTheta(0x0),
  fCorrFuncSigmaMultiplicity(0x0),
  fSplineArray()
{
  //copy ctor
  for (Int_t i=0; i<fgkNumberOfGainScenarios; i++) {fRes0[i]=that.fRes0[i];fResN2[i]=that.fResN2[i];}
 
  // Copy eta maps
  if (that.fhEtaCorr) {
    fhEtaCorr = new TH2D(*(that.fhEtaCorr));
    fhEtaCorr->SetDirectory(0);
  }
  
  if (that.fhEtaSigmaPar1) {
    fhEtaSigmaPar1 = new TH2D(*(that.fhEtaSigmaPar1));
    fhEtaSigmaPar1->SetDirectory(0);
  }
  
  // Copy multiplicity correction functions
  if (that.fCorrFuncMultiplicity) {
    fCorrFuncMultiplicity = new TF1(*(that.fCorrFuncMultiplicity));
  }
  
  if (that.fCorrFuncMultiplicityTanTheta) {
    fCorrFuncMultiplicityTanTheta = new TF1(*(that.fCorrFuncMultiplicityTanTheta));
  }
  
  if (that.fCorrFuncSigmaMultiplicity) {
    fCorrFuncSigmaMultiplicity = new TF1(*(that.fCorrFuncSigmaMultiplicity));
  }
}

//_________________________________________________________________________
AliTPCPIDResponse& AliTPCPIDResponse::operator=(const AliTPCPIDResponse& that)
{
  //assignment
  if (&that==this) return *this;
  TNamed::operator=(that);
  fMIP=that.fMIP;
  fKp1=that.fKp1;
  fKp2=that.fKp2;
  fKp3=that.fKp3;
  fKp4=that.fKp4;
  fKp5=that.fKp5;
  fUseDatabase=that.fUseDatabase;
  fResponseFunctions=that.fResponseFunctions;
  fVoltageMap=that.fVoltageMap;
  fLowGainIROCthreshold=that.fLowGainIROCthreshold;
  fBadIROCthreshhold=that.fBadIROCthreshhold;
  fLowGainOROCthreshold=that.fLowGainOROCthreshold;
  fBadOROCthreshhold=that.fBadOROCthreshhold;
  fMaxBadLengthFraction=that.fMaxBadLengthFraction;
  fMagField=that.fMagField;
  fCurrentEventMultiplicity=that.fCurrentEventMultiplicity;
  for (Int_t i=0; i<fgkNumberOfGainScenarios; i++) {fRes0[i]=that.fRes0[i];fResN2[i]=that.fResN2[i];}

  delete fhEtaCorr;
  fhEtaCorr=0x0;
  if (that.fhEtaCorr) {
    fhEtaCorr = new TH2D(*(that.fhEtaCorr));
    fhEtaCorr->SetDirectory(0);
  }
  
  delete fhEtaSigmaPar1;
  fhEtaSigmaPar1=0x0;
  if (that.fhEtaSigmaPar1) {
    fhEtaSigmaPar1 = new TH2D(*(that.fhEtaSigmaPar1));
    fhEtaSigmaPar1->SetDirectory(0);
  }
  
  fSigmaPar0 = that.fSigmaPar0;
  
  delete fCorrFuncMultiplicity;
  fCorrFuncMultiplicity = 0x0;
  if (that.fCorrFuncMultiplicity) {
    fCorrFuncMultiplicity = new TF1(*(that.fCorrFuncMultiplicity));
  }
  
  delete fCorrFuncMultiplicityTanTheta;
  fCorrFuncMultiplicityTanTheta = 0x0;
  if (that.fCorrFuncMultiplicityTanTheta) {
    fCorrFuncMultiplicityTanTheta = new TF1(*(that.fCorrFuncMultiplicityTanTheta));
  }
  
  delete fCorrFuncSigmaMultiplicity;
  fCorrFuncSigmaMultiplicity = 0x0;
  if (that.fCorrFuncSigmaMultiplicity) {
    fCorrFuncSigmaMultiplicity = new TF1(*(that.fCorrFuncSigmaMultiplicity));
  }

  return *this;
}

//_________________________________________________________________________
Double_t AliTPCPIDResponse::Bethe(Double_t betaGamma) const {
  //
  // This is the Bethe-Bloch function normalised to 1 at the minimum
  // WARNING
  // Simulated and reconstructed Bethe-Bloch differs
  //           Simulated  curve is the dNprim/dx
  //           Reconstructed is proportianal dNtot/dx
  // Temporary fix for production -  Simple linear correction function
  // Future    2 Bethe Bloch formulas needed
  //           1. for simulation
  //           2. for reconstructed PID
  //
  
//   const Float_t kmeanCorrection =0.1;
  Double_t bb=
    AliExternalTrackParam::BetheBlochAleph(betaGamma,fKp1,fKp2,fKp3,fKp4,fKp5);
  return bb*fMIP;
}

//_________________________________________________________________________
void AliTPCPIDResponse::SetBetheBlochParameters(Double_t kp1,
                             Double_t kp2,
                             Double_t kp3,
                             Double_t kp4,
                             Double_t kp5) {
  //
  // Set the parameters of the ALEPH Bethe-Bloch formula
  //
  fKp1=kp1;
  fKp2=kp2;
  fKp3=kp3;
  fKp4=kp4;
  fKp5=kp5;
}

//_________________________________________________________________________
void AliTPCPIDResponse::SetSigma(Float_t res0, Float_t resN2) {
  //
  // Set the relative resolution  sigma_rel = res0 * sqrt(1+resN2/npoint)
  //
  for (Int_t i=0; i<fgkNumberOfGainScenarios; i++) {fRes0[i]=res0;fResN2[i]=resN2;}
}

//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetExpectedSignal(Float_t mom,
					      AliPID::EParticleType n) const {
  //
  // Deprecated function (for backward compatibility). Please use 
  // GetExpectedSignal(const AliVTrack* track, AliPID::EParticleType species, ETPCdEdxSource dedxSource,
  //                   Bool_t correctEta, Bool_t correctMultiplicity);
  // instead!
  //
  //
  // Calculates the expected PID signal as the function of 
  // the information stored in the track, for the specified particle type 
  //  
  // At the moment, these signals are just the results of calling the 
  // Bethe-Bloch formula. 
  // This can be improved. By taking into account the number of
  // assigned clusters and/or the track dip angle, for example.  
  //
  
  //charge factor. BB goes with z^2, however in reality it is slightly larger (calibration, threshold effects, ...)
  // !!! Splines for light nuclei need to be normalised to this factor !!!
  const Double_t chargeFactor = TMath::Power(AliPID::ParticleCharge(n),2.3);
  
  Double_t mass=AliPID::ParticleMassZ(n);
  if (!fUseDatabase) return Bethe(mom/mass) * chargeFactor;
  //
  const TSpline3 * responseFunction = (TSpline3 *) fResponseFunctions.UncheckedAt(n);

  if (!responseFunction) return Bethe(mom/mass) * chargeFactor;
  
  return fMIP*responseFunction->Eval(mom/mass)*chargeFactor;

}

//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetExpectedSigma(Float_t mom, 
                                             Int_t nPoints,
                                             AliPID::EParticleType n) const {
  //
  // Deprecated function (for backward compatibility). Please use 
  // GetExpectedSigma(onst AliVTrack* track, AliPID::EParticleType species, 
  // ETPCdEdxSource dedxSource, Bool_t correctEta) instead!
  //
  //
  // Calculates the expected sigma of the PID signal as the function of 
  // the information stored in the track, for the specified particle type 
  //  
  
  if (nPoints != 0) 
    return GetExpectedSignal(mom,n)*fRes0[0]*sqrt(1. + fResN2[0]/nPoints);
  else
    return GetExpectedSignal(mom,n)*fRes0[0];
}

////////////////////////////////////////////////////NEW//////////////////////////////

//_________________________________________________________________________
void AliTPCPIDResponse::SetSigma(Float_t res0, Float_t resN2, ETPCgainScenario gainScenario) {
  //
  // Set the relative resolution  sigma_rel = res0 * sqrt(1+resN2/npoint)
  //
  if ((Int_t)gainScenario>=(Int_t)fgkNumberOfGainScenarios) return; //TODO: better handling!
  fRes0[gainScenario]=res0;
  fResN2[gainScenario]=resN2;
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetExpectedSignal(const AliVTrack* track,
                                              AliPID::EParticleType species,
                                              Double_t /*dEdx*/,
                                              const TSpline3* responseFunction,
                                              Bool_t correctEta,
                                              Bool_t correctMultiplicity) const 
{
  // Calculates the expected PID signal as the function of 
  // the information stored in the track and the given parameters,
  // for the specified particle type 
  //  
  // At the moment, these signals are just the results of calling the 
  // Bethe-Bloch formula plus, if desired, taking into account the eta dependence
  // and the multiplicity dependence (for PbPb). 
  // This can be improved. By taking into account the number of
  // assigned clusters and/or the track dip angle, for example.  
  //
  
  Double_t mom=track->GetTPCmomentum();
  Double_t mass=AliPID::ParticleMassZ(species);
  
  //charge factor. BB goes with z^2, however in reality it is slightly larger (calibration, threshold effects, ...)
  // !!! Splines for light nuclei need to be normalised to this factor !!!
  const Double_t chargeFactor = TMath::Power(AliPID::ParticleCharge(species),2.3);
  
  if (!responseFunction)
    return Bethe(mom/mass) * chargeFactor;
  
  Double_t dEdxSplines = fMIP*responseFunction->Eval(mom/mass) * chargeFactor;
    
  if (!correctEta && !correctMultiplicity)
    return dEdxSplines;
  
  Double_t corrFactorEta = 1.0;
  Double_t corrFactorMultiplicity = 1.0;
  
  if (correctEta) {
    corrFactorEta = GetEtaCorrectionFast(track, dEdxSplines);
    //TODO Alternatively take current track dEdx
    //corrFactorEta = GetEtaCorrectionFast(track, dEdx);
  }
  
  if (correctMultiplicity)
    corrFactorMultiplicity = GetMultiplicityCorrectionFast(track, dEdxSplines * corrFactorEta, fCurrentEventMultiplicity);

  return dEdxSplines * corrFactorEta * corrFactorMultiplicity;
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetExpectedSignal(const AliVTrack* track,
                                              AliPID::EParticleType species,
                                              ETPCdEdxSource dedxSource,
                                              Bool_t correctEta,
                                              Bool_t correctMultiplicity) const
{
  // Calculates the expected PID signal as the function of 
  // the information stored in the track, for the specified particle type 
  //  
  // At the moment, these signals are just the results of calling the 
  // Bethe-Bloch formula plus, if desired, taking into account the eta dependence
  // and the multiplicity dependence (for PbPb). 
  // This can be improved. By taking into account the number of
  // assigned clusters and/or the track dip angle, for example.  
  //
  
  if (!fUseDatabase) {
    //charge factor. BB goes with z^2, however in reality it is slightly larger (calibration, threshold effects, ...)
    // !!! Splines for light nuclei need to be normalised to this factor !!!
    const Double_t chargeFactor = TMath::Power(AliPID::ParticleCharge(species),2.3);
  
    return Bethe(track->GetTPCmomentum() / AliPID::ParticleMassZ(species)) * chargeFactor;
  }
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
    
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction)) {
    // Something is wrong with the track -> Return obviously invalid value
    return -999;
  }
  
  // Charge factor already taken into account inside the following function call
  return GetExpectedSignal(track, species, dEdx, responseFunction, correctEta, correctMultiplicity);
}
  
//_________________________________________________________________________
TSpline3* AliTPCPIDResponse::GetResponseFunction( AliPID::EParticleType type,
                                                  AliTPCPIDResponse::ETPCgainScenario gainScenario ) const
{
  //get response function
  return dynamic_cast<TSpline3*>(fResponseFunctions.At(ResponseFunctionIndex(type,gainScenario)));
}

//_________________________________________________________________________
TSpline3* AliTPCPIDResponse::GetResponseFunction( const AliVTrack* track,
                               AliPID::EParticleType species,
                               ETPCdEdxSource dedxSource) const 
{
  //the splines are stored in an array, different scenarios

  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  if (ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return responseFunction;
  
  return NULL;
}

//_________________________________________________________________________
void AliTPCPIDResponse::ResetSplines()
{
  //reset the array with splines
  for (Int_t i=0;i<fResponseFunctions.GetEntriesFast();i++)
  {
    fResponseFunctions.AddAt(NULL,i);
  }
}
//_________________________________________________________________________
Int_t AliTPCPIDResponse::ResponseFunctionIndex( AliPID::EParticleType species,
                                                ETPCgainScenario gainScenario ) const
{
  //get the index in fResponseFunctions given type and scenario
  return Int_t(species)+Int_t(gainScenario)*fgkNumberOfParticleSpecies;
}

//_________________________________________________________________________
void AliTPCPIDResponse::SetResponseFunction( TObject* o,
                                             AliPID::EParticleType species,
                                             ETPCgainScenario gainScenario )
{
  fResponseFunctions.AddAtAndExpand(o,ResponseFunctionIndex(species,gainScenario));
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetExpectedSigma(const AliVTrack* track, 
                                             AliPID::EParticleType species,
                                             ETPCgainScenario gainScenario,
                                             Double_t dEdx,
                                             Int_t nPoints,
                                             const TSpline3* responseFunction,
                                             Bool_t correctEta,
                                             Bool_t correctMultiplicity) const 
{
  // Calculates the expected sigma of the PID signal as the function of 
  // the information stored in the track and the given parameters,
  // for the specified particle type 
  //
  
  if (!responseFunction)
    return 999;
    
  //TODO Check whether it makes sense to set correctMultiplicity to kTRUE while correctEta might be kFALSE
  
  // If eta correction (=> new sigma parametrisation) is requested, but no sigma map is available, print error message
  if (correctEta && !fhEtaSigmaPar1) {
    AliError("New sigma parametrisation requested, but sigma map not initialised (usually via AliPIDResponse). Old sigma parametrisation will be used!");
  }
  
  // If no sigma map is available or if no eta correction is requested (sigma maps only for corrected eta!), use the old parametrisation
  if (!fhEtaSigmaPar1 || !correctEta) {  
    if (nPoints != 0) 
      return GetExpectedSignal(track, species, dEdx, responseFunction, kFALSE, correctMultiplicity) *
               fRes0[gainScenario] * sqrt(1. + fResN2[gainScenario]/nPoints);
    else
      return GetExpectedSignal(track, species, dEdx, responseFunction, kFALSE, correctMultiplicity)*fRes0[gainScenario];
  }
    
  if (nPoints > 0) {
    // Use eta correction (+ eta-dependent sigma)
    Double_t sigmaPar1 = GetSigmaPar1Fast(track, species, dEdx, responseFunction);
    
    if (correctMultiplicity) {
      // In addition, take into account multiplicity dependence of mean and sigma of dEdx
      Double_t dEdxExpectedEtaCorrected = GetExpectedSignal(track, species, dEdx, responseFunction, kTRUE, kFALSE);
      
      // GetMultiplicityCorrection and GetMultiplicitySigmaCorrection both need the eta corrected dEdxExpected
      Double_t multiplicityCorrFactor = GetMultiplicityCorrectionFast(track, dEdxExpectedEtaCorrected, fCurrentEventMultiplicity);
      Double_t multiplicitySigmaCorrFactor = GetMultiplicitySigmaCorrectionFast(dEdxExpectedEtaCorrected, fCurrentEventMultiplicity);
      
      // multiplicityCorrFactor to correct dEdxExpected for multiplicity. In addition: Correction factor for sigma
      return (dEdxExpectedEtaCorrected * multiplicityCorrFactor) 
              * (sqrt(fSigmaPar0 * fSigmaPar0 + sigmaPar1 * sigmaPar1 / nPoints) * multiplicitySigmaCorrFactor);
    }
    else {
      return GetExpectedSignal(track, species, dEdx, responseFunction, kTRUE, kFALSE)*
             sqrt(fSigmaPar0 * fSigmaPar0 + sigmaPar1 * sigmaPar1 / nPoints);
    }
  }
  else { 
    // One should never have/take tracks with 0 dEdx clusters!
    return 999;
  }
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetExpectedSigma(const AliVTrack* track, 
                                             AliPID::EParticleType species,
                                             ETPCdEdxSource dedxSource,
                                             Bool_t correctEta,
                                             Bool_t correctMultiplicity) const 
{
  // Calculates the expected sigma of the PID signal as the function of 
  // the information stored in the track, for the specified particle type 
  // and dedx scenario
  //
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return 999; //TODO: better handling!
  
  return GetExpectedSigma(track, species, gainScenario, dEdx, nPoints, responseFunction, correctEta, correctMultiplicity);
}


//_________________________________________________________________________
Float_t AliTPCPIDResponse::GetNumberOfSigmas(const AliVTrack* track, 
                             AliPID::EParticleType species,
                             ETPCdEdxSource dedxSource,
                             Bool_t correctEta,
                             Bool_t correctMultiplicity) const
{
  //Calculates the number of sigmas of the PID signal from the expected value
  //for a given particle species in the presence of multiple gain scenarios
  //inside the TPC
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return -999; //TODO: Better handling!
    
  Double_t bethe = GetExpectedSignal(track, species, dEdx, responseFunction, correctEta, correctMultiplicity);
  Double_t sigma = GetExpectedSigma(track, species, gainScenario, dEdx, nPoints, responseFunction, correctEta, correctMultiplicity);
  // 999 will be returned by GetExpectedSigma e.g. in case of 0 dEdx clusters
  if (sigma >= 998) 
    return -999;
  else
    return (dEdx-bethe)/sigma;
}

//_________________________________________________________________________
Float_t AliTPCPIDResponse::GetSignalDelta(const AliVTrack* track,
                                          AliPID::EParticleType species,
                                          ETPCdEdxSource dedxSource,
                                          Bool_t correctEta,
                                          Bool_t correctMultiplicity,
                                          Bool_t ratio/*=kFALSE*/)const
{
  //Calculates the number of sigmas of the PID signal from the expected value
  //for a given particle species in the presence of multiple gain scenarios
  //inside the TPC

  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;

  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return -9999.; //TODO: Better handling!

  const Double_t bethe = GetExpectedSignal(track, species, dEdx, responseFunction, correctEta, correctMultiplicity);

  Double_t delta=-9999.;
  if (!ratio) delta=dEdx-bethe;
  else if (bethe>1.e-20) delta=dEdx/bethe;
  
  return delta;
}

//_________________________________________________________________________
Bool_t AliTPCPIDResponse::ResponseFunctiondEdxN( const AliVTrack* track, 
                                                 AliPID::EParticleType species,
                                                 ETPCdEdxSource dedxSource,
                                                 Double_t& dEdx,
                                                 Int_t& nPoints,
                                                 ETPCgainScenario& gainScenario,
                                                 TSpline3** responseFunction) const 
{
  // Calculates the right parameters for PID
  //   dEdx parametrization for the proper gain scenario, dEdx 
  //   and NPoints used for dEdx
  // based on the track geometry (which chambers it crosses) for the specified particle type 
  // and preferred source of dedx.
  // returns true on success
  
  
  if (dedxSource == kdEdxDefault) {
    // Fast handling for default case. In addition: Keep it simple (don't call additional functions) to
    // avoid possible bugs
    
    // GetTPCsignalTunedOnData will be non-positive, if it has not been set (i.e. in case of MC NOT tuned to data).
    // If this is the case, just take the normal signal
    dEdx = track->GetTPCsignalTunedOnData();
    if (dEdx <= 0) {
      dEdx = track->GetTPCsignal();
    }
    
    nPoints = track->GetTPCsignalN();
    gainScenario = kDefault;
    
    TObject* obj = fResponseFunctions.UncheckedAt(ResponseFunctionIndex(species,gainScenario));
    *responseFunction = dynamic_cast<TSpline3*>(obj); //TODO:maybe static cast?
  
    return kTRUE;
  }
  
  //TODO Proper handle of tuneMConData for other dEdx sources
  
  Double32_t signal[4]; //0: IROC, 1: OROC medium, 2:OROC long, 3: OROC all (def. truncation used)
  Char_t ncl[3];        //same
  Char_t nrows[3];      //same
  const AliTPCdEdxInfo* dEdxInfo = track->GetTPCdEdxInfo();
  
  if (!dEdxInfo && dedxSource!=kdEdxDefault)  //in one case its ok if we dont have the info
  {
    AliError("AliTPCdEdxInfo not available");
    return kFALSE;
  }

  if (dEdxInfo) dEdxInfo->GetTPCSignalRegionInfo(signal,ncl,nrows);

  //check if we cross a bad OROC in which case we reject
  EChamberStatus trackOROCStatus = TrackStatus(track,2);
  if (trackOROCStatus==kChamberOff || trackOROCStatus==kChamberLowGain)
  {
    return kFALSE;
  }

  switch (dedxSource)
  {
    case kdEdxOROC:
      {
        if (trackOROCStatus==kChamberInvalid) return kFALSE; //never reached OROC
        dEdx = signal[3];
        nPoints = ncl[2]+ncl[1];
        gainScenario = kOROChigh;
        break;
      }
    case kdEdxHybrid:
      {
        //if we cross a bad IROC we use OROC dedx, if we dont we use combined
        EChamberStatus status = TrackStatus(track,1);
        if (status!=kChamberHighGain)
        {
          dEdx = signal[3];
          nPoints = ncl[2]+ncl[1];
          gainScenario = kOROChigh;
        }
        else
        {
          dEdx = track->GetTPCsignal();
          nPoints = track->GetTPCsignalN();
          gainScenario = kALLhigh;
        }
        break;
      }
    default:
      {
         dEdx = 0.;
         nPoints = 0;
         gainScenario = kGainScenarioInvalid;
         return kFALSE;
      }
  }
  TObject* obj = fResponseFunctions.UncheckedAt(ResponseFunctionIndex(species,gainScenario));
  *responseFunction = dynamic_cast<TSpline3*>(obj); //TODO:maybe static cast?
  
  return kTRUE;
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetEtaCorrectionFast(const AliVTrack *track, Double_t dEdxSplines) const
{
  // NOTE: For expert use only -> Non-experts are advised to use the function without the "Fast" suffix or stick to AliPIDResponse directly.
  //
  // Get eta correction for the given parameters.
  //
  
  if (!fhEtaCorr) {
    // Calling this function means to request eta correction in some way. Print error message, if no map is available!
    AliError("Eta correction requested, but map not initialised (usually via AliPIDResponse). Returning eta correction factor 1!");
    return 1.;
  }
  
  Double_t tpcSignal = dEdxSplines;
  
  if (tpcSignal < 1.)
    return 1.;
  
  Double_t tanTheta = GetTrackTanTheta(track); 
  Int_t binX = fhEtaCorr->GetXaxis()->FindFixBin(tanTheta);
  Int_t binY = fhEtaCorr->GetYaxis()->FindFixBin(1. / tpcSignal);
  
  if (binX == 0) 
    binX = 1;
  if (binX > fhEtaCorr->GetXaxis()->GetNbins())
    binX = fhEtaCorr->GetXaxis()->GetNbins();
  
  if (binY == 0)
    binY = 1;
  if (binY > fhEtaCorr->GetYaxis()->GetNbins())
    binY = fhEtaCorr->GetYaxis()->GetNbins();
  
  return fhEtaCorr->GetBinContent(binX, binY);
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetEtaCorrection(const AliVTrack *track, AliPID::EParticleType species, ETPCdEdxSource dedxSource) const
{
  //
  // Get eta correction for the given track.
  //
  
  if (!fhEtaCorr)
    return 1.;
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return 1.; 
  
  // For the eta correction, do NOT take the multiplicity corrected value of dEdx
  Double_t dEdxSplines = GetExpectedSignal(track, species, dEdx, responseFunction, kFALSE, kFALSE);
  
  //TODO Alternatively take current track dEdx
  //return GetEtaCorrectionFast(track, dEdx);
  
  return GetEtaCorrectionFast(track, dEdxSplines);
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetEtaCorrectedTrackdEdx(const AliVTrack *track, AliPID::EParticleType species, ETPCdEdxSource dedxSource) const
{
  //
  // Get eta corrected dEdx for the given track. For the correction, the expected dEdx of
  // the specified species will be used. If the species is set to AliPID::kUnknown, the
  // dEdx of the track is used instead.
  // WARNING: In the latter case, the eta correction might not be as good as if the
  // expected dEdx is used, which is the way the correction factor is designed
  // for.
  // In any case, one has to decide carefully to which expected signal one wants to
  // compare the corrected value - to the corrected or uncorrected.
  // Anyhow, a safer way of looking e.g. at the n-sigma is to call
  // the corresponding function GetNumberOfSigmas!
  //
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  // Note: In case of species == AliPID::kUnknown, the responseFunction might not be set. However, in this case
  // it is not used anyway, so this causes no trouble.
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return -1.;
  
  Double_t etaCorr = 0.;
  
  if (species < AliPID::kUnknown) {
    // For the eta correction, do NOT take the multiplicity corrected value of dEdx
    Double_t dEdxSplines = GetExpectedSignal(track, species, dEdx, responseFunction, kFALSE, kFALSE);
    etaCorr = GetEtaCorrectionFast(track, dEdxSplines);
  }
  else {
    etaCorr = GetEtaCorrectionFast(track, dEdx);
  }
    
  if (etaCorr <= 0)
    return -1.;
  
  return dEdx / etaCorr; 
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetSigmaPar1Fast(const AliVTrack *track, AliPID::EParticleType species, Double_t dEdx,
                                             const TSpline3* responseFunction) const
{
  // NOTE: For expert use only -> Non-experts are advised to use the function without the "Fast" suffix or stick to AliPIDResponse directly.
  //
  // Get parameter 1 of sigma parametrisation of TPC dEdx from the histogram for the given track.
  //
  
  if (!fhEtaSigmaPar1) {
    // Calling this function means to request new sigma parametrisation in some way. Print error message, if no map is available!
    AliError("New sigma parametrisation requested, but sigma map not initialised (usually via AliPIDResponse). Returning error value for sigma parameter1 = 999!");
    return 999;
  }
  
  // The sigma maps are created with data sets that are already eta corrected and for which the 
  // splines have been re-created. Therefore, the value for the lookup needs to be the value of
  // the splines without any additional eta correction.
  // NOTE: This is due to the method the maps are created. The track dEdx (not the expected one!)
  // is corrected to uniquely related a momemtum bin with an expected dEdx, where the expected dEdx
  // equals the track dEdx for all eta (thanks to the correction and the re-fit of the splines).
  // Consequently, looking up the uncorrected expected dEdx at a given tanTheta yields the correct
  // sigma parameter!
  // Also: It has to be the spline dEdx, since one wants to get the sigma for the assumption(!)
  // of such a particle, which by assumption then has this dEdx value
  
  // For the eta correction, do NOT take the multiplicity corrected value of dEdx
  Double_t dEdxExpected = GetExpectedSignal(track, species, dEdx, responseFunction, kFALSE, kFALSE);
  
  if (dEdxExpected < 1.)
    return 999;
  
  Double_t tanTheta = GetTrackTanTheta(track);
  Int_t binX = fhEtaSigmaPar1->GetXaxis()->FindFixBin(tanTheta);
  Int_t binY = fhEtaSigmaPar1->GetYaxis()->FindFixBin(1. / dEdxExpected);
    
  if (binX == 0) 
    binX = 1;
  if (binX > fhEtaSigmaPar1->GetXaxis()->GetNbins())
    binX = fhEtaSigmaPar1->GetXaxis()->GetNbins();
    
  if (binY == 0)
    binY = 1;
  if (binY > fhEtaSigmaPar1->GetYaxis()->GetNbins())
    binY = fhEtaSigmaPar1->GetYaxis()->GetNbins();
    
  return fhEtaSigmaPar1->GetBinContent(binX, binY);
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetSigmaPar1(const AliVTrack *track, AliPID::EParticleType species, ETPCdEdxSource dedxSource) const
{
  //
  // Get parameter 1 of sigma parametrisation of TPC dEdx from the histogram for the given track.
  //
  
  if (!fhEtaSigmaPar1)
    return 999;
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return 999; 
  
  return GetSigmaPar1Fast(track, species, dEdx, responseFunction);
}


//_________________________________________________________________________
Bool_t AliTPCPIDResponse::SetEtaCorrMap(TH2D* hMap)
{
  //
  // Load map for TPC eta correction (a copy is stored and will be deleted automatically).
  // If hMap is 0x0,the eta correction will be disabled and kFALSE is returned. 
  // If the map can be set, kTRUE is returned.
  //
  
  delete fhEtaCorr;
  
  if (!hMap) {
    fhEtaCorr = 0x0;
    
    return kFALSE;
  }
  
  fhEtaCorr = (TH2D*)(hMap->Clone());
  fhEtaCorr->SetDirectory(0);
      
  return kTRUE;
}


//_________________________________________________________________________
Bool_t AliTPCPIDResponse::SetSigmaParams(TH2D* hSigmaPar1Map, Double_t sigmaPar0)
{
  //
  // Load map for TPC sigma map (a copy is stored and will be deleted automatically):
  // Parameter 1 is stored as a 2D map (1/dEdx vs. tanTheta_local) and parameter 0 is
  // a constant. If hSigmaPar1Map is 0x0, the old sigma parametrisation will be used
  // (and sigmaPar0 is ignored!) and kFALSE is returned. 
  // If the map can be set, sigmaPar0 is also set and kTRUE will be returned.
  //
  
  delete fhEtaSigmaPar1;
  
  if (!hSigmaPar1Map) {
    fhEtaSigmaPar1 = 0x0;
    fSigmaPar0 = 0.0;
    
    return kFALSE;
  }
  
  fhEtaSigmaPar1 = (TH2D*)(hSigmaPar1Map->Clone());
  fhEtaSigmaPar1->SetDirectory(0);
  fSigmaPar0 = sigmaPar0;
  
  return kTRUE;
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetTrackTanTheta(const AliVTrack *track) const
{
  // Extract the tanTheta from the information available in the AliVTrack
  
  // For ESD tracks, the local tanTheta could be used (esdTrack->GetInnerParam()->GetTgl()).
  // However, this value is not available for AODs and, thus, not for AliVTrack.
  // Fortunately, the following formula allows to approximate the local tanTheta with the 
  // global theta angle -> This is for by far most of the tracks the same, but gives at
  // maybe the percent level differences within +- 0.2 in tanTheta -> Which is still ok.
  
  /*
  const AliExternalTrackParam* innerParam = track->GetInnerParam();
  Double_t tanTheta = 0;
  if (innerParam) 
    tanTheta = innerParam->GetTgl();
  else
    tanTheta = TMath::Tan(-track->Theta() + TMath::Pi() / 2.0);
  
  // Constant in formula for B in kGauss (factor 0.1 to convert B from Tesla to kGauss),
  // pT in GeV/c (factor c*1e-9 to arrive at GeV/c) and curvature in 1/cm (factor 0.01 to get from m to cm)
  const Double_t constant = TMath::C()* 1e-9 * 0.1 * 0.01; 
  const Double_t curvature = fMagField * constant / track->Pt(); // in 1./cm
  
  Double_t averageddzdr = 0.;
  Int_t nParts = 0;

  for (Double_t r = 85; r < 245; r++) {
    Double_t sinPhiLocal = TMath::Abs(r*curvature*0.5);
    
    // Cut on |sin(phi)| as during reco
    if (TMath::Abs(sinPhiLocal) <= 0.95) {
      const Double_t phiLocal = TMath::ASin(sinPhiLocal);
      const Double_t tanPhiLocal = TMath::Tan(phiLocal);
      
      averageddzdr += tanTheta * TMath::Sqrt(1. + tanPhiLocal * tanPhiLocal); 
      nParts++;
    }
  }
  
  if (nParts > 0)
    averageddzdr /= nParts; 
  else {
    AliError("Problems during determination of dz/dr. Returning pure tanTheta as best estimate!");
    return tanTheta;
  }
  
  //printf("pT: %f\nFactor/magField(kGs)/curvature^-1: %f / %f /%f\ntanThetaGlobalFromTheta/tanTheta/Averageddzdr: %f / %f / %f\n\n",
  //          track->Pt(), constant, fMagField, 1./curvature, TMath::Tan(-track->Theta() + TMath::Pi() / 2.0), tanTheta, averageddzdr);
  
  return averageddzdr;
  */
  
  
  // Alternatively (in average, the effect is found to be negligable!):
  // Take local tanTheta from TPC inner wall, if available (currently only for ESDs available)
  //const AliExternalTrackParam* innerParam = track->GetInnerParam();
  //if (innerParam) {
  //  return innerParam->GetTgl();
  //}
  
  return TMath::Tan(-track->Theta() + TMath::Pi() / 2.0);
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetMultiplicityCorrectionFast(const AliVTrack *track, Double_t dEdxExpected, Int_t multiplicity) const
{
  // NOTE: For expert use only -> Non-experts are advised to use the function without the "Fast" suffix or stick to AliPIDResponse directly.
  //
  // Calculate the multiplicity correction factor for this track for the given multiplicity.
  // The parameter dEdxExpected should take into account the eta correction already!
  
  // Multiplicity depends on pure dEdx. Therefore, correction factor depends indirectly on eta
  // => Use eta corrected value for dEdexExpected.
  
  if (dEdxExpected <= 0 || multiplicity <= 0)
    return 1.0;
  
  const Double_t dEdxExpectedInv = 1. / dEdxExpected;
  Double_t relSlope = fCorrFuncMultiplicity->Eval(dEdxExpectedInv);
  
  const Double_t tanTheta = GetTrackTanTheta(track);
  relSlope += fCorrFuncMultiplicityTanTheta->Eval(tanTheta);

  return (1. + relSlope * multiplicity);
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetMultiplicityCorrection(const AliVTrack *track, AliPID::EParticleType species, ETPCdEdxSource dedxSource) const
{
  //
  // Get multiplicity correction for the given track (w.r.t. the mulitplicity of the current event)
  //
  
  //TODO Should return error value, if no eta correction is enabled (needs eta correction). OR: Reset correction in case of no eta correction in PIDresponse
  
  // No correction in case of multiplicity <= 0
  if (fCurrentEventMultiplicity <= 0)
    return 1.;
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return 1.; 
  
  //TODO Does it make sense to use the multiplicity correction WITHOUT eta correction?! Are the fit parameters still valid?
  // To get the expected signal to determine the multiplicity correction, do NOT ask for the multiplicity corrected value (of course)
  Double_t dEdxExpected = GetExpectedSignal(track, species, dEdx, responseFunction, kTRUE, kFALSE);
  
  return GetMultiplicityCorrectionFast(track, dEdxExpected, fCurrentEventMultiplicity);
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetMultiplicityCorrectedTrackdEdx(const AliVTrack *track, AliPID::EParticleType species, ETPCdEdxSource dedxSource) const
{
  //
  // Get multiplicity corrected dEdx for the given track. For the correction, the expected dEdx of
  // the specified species will be used. If the species is set to AliPID::kUnknown, the
  // dEdx of the track is used instead.
  // WARNING: In the latter case, the correction might not be as good as if the
  // expected dEdx is used, which is the way the correction factor is designed
  // for.
  // In any case, one has to decide carefully to which expected signal one wants to
  // compare the corrected value - to the corrected or uncorrected.
  // Anyhow, a safer way of looking e.g. at the n-sigma is to call
  // the corresponding function GetNumberOfSigmas!
  //
  
  //TODO Should return error value, if no eta correction is enabled (needs eta correction). OR: Reset correction in case of no eta correction in PIDresponse
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  // Note: In case of species == AliPID::kUnknown, the responseFunction might not be set. However, in this case
  // it is not used anyway, so this causes no trouble.
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return -1.;
  
  
  // No correction in case of multiplicity <= 0
  if (fCurrentEventMultiplicity <= 0)
    return dEdx;
  
  Double_t multiplicityCorr = 0.;
  
  // TODO Normally, one should use the eta corrected values in BOTH of the following cases. Does it make sense to use the uncorrected dEdx values?
  if (species < AliPID::kUnknown) {
    // To get the expected signal to determine the multiplicity correction, do NOT ask for the multiplicity corrected value (of course).
    // However, one needs the eta corrected value!
    Double_t dEdxSplines = GetExpectedSignal(track, species, dEdx, responseFunction, kTRUE, kFALSE);
    multiplicityCorr = GetMultiplicityCorrectionFast(track, dEdxSplines, fCurrentEventMultiplicity);
  }
  else {
    // One needs the eta corrected value to determine the multiplicity correction factor!
    Double_t etaCorr = GetEtaCorrectionFast(track, dEdx);
    multiplicityCorr = GetMultiplicityCorrectionFast(track, dEdx * etaCorr, fCurrentEventMultiplicity);
  }
    
  if (multiplicityCorr <= 0)
    return -1.;
  
  return dEdx / multiplicityCorr; 
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetEtaAndMultiplicityCorrectedTrackdEdx(const AliVTrack *track, AliPID::EParticleType species,
                                                                    ETPCdEdxSource dedxSource) const
{
  //
  // Get multiplicity and eta corrected dEdx for the given track. For the correction,
  // the expected dEdx of the specified species will be used. If the species is set 
  // to AliPID::kUnknown, the dEdx of the track is used instead.
  // WARNING: In the latter case, the correction might not be as good as if the
  // expected dEdx is used, which is the way the correction factor is designed
  // for.
  // In any case, one has to decide carefully to which expected signal one wants to
  // compare the corrected value - to the corrected or uncorrected.
  // Anyhow, a safer way of looking e.g. at the n-sigma is to call
  // the corresponding function GetNumberOfSigmas!
  //
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  // Note: In case of species == AliPID::kUnknown, the responseFunction might not be set. However, in this case
  // it is not used anyway, so this causes no trouble.
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return -1.;
  
  Double_t multiplicityCorr = 0.;
  Double_t etaCorr = 0.;
    
  if (species < AliPID::kUnknown) {
    // To get the expected signal to determine the multiplicity correction, do NOT ask for the multiplicity corrected value (of course)
    Double_t dEdxSplines = GetExpectedSignal(track, species, dEdx, responseFunction, kFALSE, kFALSE);
    etaCorr = GetEtaCorrectionFast(track, dEdxSplines);
    multiplicityCorr = GetMultiplicityCorrectionFast(track, dEdxSplines * etaCorr, fCurrentEventMultiplicity);
  }
  else {
    etaCorr = GetEtaCorrectionFast(track, dEdx);
    multiplicityCorr = GetMultiplicityCorrectionFast(track, dEdx * etaCorr, fCurrentEventMultiplicity);
  }
    
  if (multiplicityCorr <= 0 || etaCorr <= 0)
    return -1.;
  
  return dEdx / multiplicityCorr / etaCorr; 
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetMultiplicitySigmaCorrectionFast(Double_t dEdxExpected, Int_t multiplicity) const
{
  // NOTE: For expert use only -> Non-experts are advised to use the function without the "Fast" suffix or stick to AliPIDResponse directly.
  //
  // Calculate the multiplicity sigma correction factor for the corresponding expected dEdx and for the given multiplicity.
  // The parameter dEdxExpected should take into account the eta correction already!
  
  // Multiplicity dependence of sigma depends on the real dEdx at zero multiplicity,
  // i.e. the eta (only) corrected dEdxExpected value has to be used
  // since all maps etc. have been created for ~zero multiplicity
  
  if (dEdxExpected <= 0 || multiplicity <= 0)
    return 1.0;
  
  Double_t relSigmaSlope = fCorrFuncSigmaMultiplicity->Eval(1. / dEdxExpected);
 
  return (1. + relSigmaSlope * multiplicity);
}


//_________________________________________________________________________
Double_t AliTPCPIDResponse::GetMultiplicitySigmaCorrection(const AliVTrack *track, AliPID::EParticleType species, ETPCdEdxSource dedxSource) const
{
  //
  // Get multiplicity sigma correction for the given track (w.r.t. the mulitplicity of the current event)
  //
  
  //TODO Should return error value, if no eta correction is enabled (needs eta correction). OR: Reset correction in case of no eta correction in PIDresponse
  
  // No correction in case of multiplicity <= 0
  if (fCurrentEventMultiplicity <= 0)
    return 1.;
  
  Double_t dEdx = -1;
  Int_t nPoints = -1;
  ETPCgainScenario gainScenario = kGainScenarioInvalid;
  TSpline3* responseFunction = 0x0;
  
  if (!ResponseFunctiondEdxN(track, species, dedxSource, dEdx, nPoints, gainScenario, &responseFunction))
    return 1.; 
  
  //TODO Does it make sense to use the multiplicity correction WITHOUT eta correction?! Are the fit parameters still valid?
  // To get the expected signal to determine the multiplicity correction, do NOT ask for the multiplicity corrected value (of course)
  Double_t dEdxExpected = GetExpectedSignal(track, species, dEdx, responseFunction, kTRUE, kFALSE);
  
  return GetMultiplicitySigmaCorrectionFast(dEdxExpected, fCurrentEventMultiplicity);
}


//_________________________________________________________________________
void AliTPCPIDResponse::ResetMultiplicityCorrectionFunctions()
{
  // Default values: No correction, i.e. overall correction factor should be one
  
  // This function should always return 0.0, if multcorr disabled
  fCorrFuncMultiplicity->SetParameter(0, 0.);
  fCorrFuncMultiplicity->SetParameter(1, 0.);
  fCorrFuncMultiplicity->SetParameter(2, 0.);
  fCorrFuncMultiplicity->SetParameter(3, 0.);
  fCorrFuncMultiplicity->SetParameter(4, 0.);
    
  // This function should always return 0., if multCorr disabled
  fCorrFuncMultiplicityTanTheta->SetParameter(0, 0.);
  fCorrFuncMultiplicityTanTheta->SetParameter(1, 0.);
  fCorrFuncMultiplicityTanTheta->SetParameter(2, 0.);
  
  // This function should always return 0.0, if mutlcorr disabled
  fCorrFuncSigmaMultiplicity->SetParameter(0, 0.);
  fCorrFuncSigmaMultiplicity->SetParameter(1, 0.);
  fCorrFuncSigmaMultiplicity->SetParameter(2, 0.);
  fCorrFuncSigmaMultiplicity->SetParameter(3, 0.);
}


//_________________________________________________________________________
Bool_t AliTPCPIDResponse::sectorNumbersInOut(Double_t* trackPositionInner,
                                             Double_t* trackPositionOuter,
                                             Float_t& inphi,
                                             Float_t& outphi,
                                             Int_t& in,
                                             Int_t& out ) const
{
  //calculate the sector numbers (equivalent to IROC chamber numbers) a track crosses
  //for OROC chamber numbers add 36
  //returned angles are between (0,2pi)

  inphi = TMath::ATan2(trackPositionInner[1],trackPositionInner[0]);
  outphi = TMath::ATan2(trackPositionOuter[1], trackPositionOuter[0]);

  if (inphi<0) {inphi+=TMath::TwoPi();} //because ATan2 gives angles between -pi,pi
  if (outphi<0) {outphi+=TMath::TwoPi();} //because ATan2 gives angles between -pi,pi

  in = sectorNumber(inphi);
  out = sectorNumber(outphi);

  //for the C side (positive z) offset by 18
  if (trackPositionInner[2]>0.0)
  {
    in+=18;
    out+=18;
  }
  return kTRUE;
}


//_____________________________________________________________________________
Int_t AliTPCPIDResponse::sectorNumber(Double_t phi) const
{
  //calculate sector number
  const Float_t width=TMath::TwoPi()/18.;
  return TMath::Floor(phi/width);
}


//_____________________________________________________________________________
void AliTPCPIDResponse::Print(Option_t* /*option*/) const
{
  //Print info
  fResponseFunctions.Print();
}


//_____________________________________________________________________________
AliTPCPIDResponse::EChamberStatus AliTPCPIDResponse::TrackStatus(const AliVTrack* track, Int_t layer) const
{
  //status of the track: if it crosses any bad chambers return kChamberOff;
  //IROC:layer=1, OROC:layer=2
  if (layer<1 || layer>2) layer=1;
  Int_t in=0;
  Int_t out=0;
  Float_t inphi=0.;
  Float_t outphi=0.;
  Float_t innerRadius = (layer==1)?83.0:133.7;
  Float_t outerRadius = (layer==1)?133.5:247.7;

  /////////////////////////////////////////////////////////////////////////////
  //find out where track enters and leaves the layer.
  //
  Double_t trackPositionInner[3];
  Double_t trackPositionOuter[3];
 
  //if there is no inner param this could mean we're using the AOD track,
  //we still can extrapolate from the vertex - so use those params.
  const AliExternalTrackParam* ip = track->GetInnerParam();
  if (ip) track=dynamic_cast<const AliVTrack*>(ip);

  Bool_t trackAtInner = track->GetXYZAt(innerRadius, fMagField, trackPositionInner);
  Bool_t trackAtOuter = track->GetXYZAt(outerRadius, fMagField, trackPositionOuter);

  if (!trackAtInner)
  {
    //if we dont even enter inner radius we do nothing and return invalid
    inphi=0.0;
    outphi=0.0;
    in=0;
    out=0;
    return kChamberInvalid;
  }

  if (!trackAtOuter)
  {
    //if we don't reach the outer radius check that the apex is indeed within the outer radius and use apex position
    Bool_t haveApex = TrackApex(track, fMagField, trackPositionOuter);
    Float_t apexRadius = TMath::Sqrt(trackPositionOuter[0]*trackPositionOuter[0]+trackPositionOuter[1]*trackPositionOuter[1]);
    if ( haveApex && apexRadius<=outerRadius && apexRadius>innerRadius)
    {
      //printf("pt: %.2f, apexRadius: %.2f(%s), x: %.2f, y: %.2f\n",track->Pt(),apexRadius,(haveApex)?"OK":"BAD",trackPositionOuter[0],trackPositionOuter[1]);
    }
    else
    {
      inphi=0.0;
      outphi=0.0;
      in=0;
      out=0;
      return kChamberInvalid;
    }
  }


  if (!sectorNumbersInOut(trackPositionInner,
                          trackPositionOuter,
                          inphi,
                          outphi,
                          in,
                          out)) return kChamberInvalid;

  /////////////////////////////////////////////////////////////////////////////
  //now we have the location of the track we can check
  //if it is in a good/bad chamber
  //
  Bool_t sideA = kTRUE;
 
  if (((in/18)%2==1) && ((out/18)%2==1)) sideA=kFALSE;

  in=in%18;
  out=out%18;

  if (TMath::Abs(in-out)>9)
  {
    if (TMath::Max(in,out)==out)
    {
      Int_t tmp=out;
      out = in;
      in = tmp;
      Float_t tmpphi=outphi;
      outphi=inphi;
      inphi=tmpphi;
    }
    in-=18;
    inphi-=TMath::TwoPi();
  }
  else
  {
    if (TMath::Max(in,out)==in)
    {
      Int_t tmp=out;
      out=in;
      in=tmp;
      Float_t tmpphi=outphi;
      outphi=inphi;
      inphi=tmpphi;
    }
  }

  Float_t trackLengthInBad = 0.;
  Float_t trackLengthInLowGain = 0.;
  Float_t trackLengthTotal = TMath::Abs(outphi-inphi);
  Float_t lengthFractionInBadSectors = 0.;

  const Float_t sectorWidth = TMath::TwoPi()/18.;  
 
  for (Int_t i=in; i<=out; i++)
  {
    int j=i;
    if (i<0) j+=18;    //correct for the negative values
    if (!sideA) j+=18; //move to the correct side
   
    Float_t deltaPhi = 0.;
    Float_t phiEdge=sectorWidth*i;
    if (inphi>phiEdge) {deltaPhi=phiEdge+sectorWidth-inphi;}
    else if ((outphi>=phiEdge) && (outphi<(phiEdge+sectorWidth))) {deltaPhi=outphi-phiEdge;}
    else {deltaPhi=sectorWidth;}
   
    Float_t v = fVoltageMap[(layer==1)?(j):(j+36)];
    if (v<=fBadIROCthreshhold)
    {
      trackLengthInBad+=deltaPhi;
      lengthFractionInBadSectors=1.;
    }
    if (v<=fLowGainIROCthreshold && v>fBadIROCthreshhold)
    {
      trackLengthInLowGain+=deltaPhi;
      lengthFractionInBadSectors=1.;
    }
  }

  //for now low gain and bad (off) chambers are treated equally
  if (trackLengthTotal>0)
    lengthFractionInBadSectors = (trackLengthInLowGain+trackLengthInBad)/trackLengthTotal;

  //printf("### side: %s, pt: %.2f, pz: %.2f, in: %i, out: %i, phiIN: %.2f, phiOUT: %.2f, rIN: %.2f, rOUT: %.2f\n",(sideA)?"A":"C",track->Pt(),track->Pz(),in,out,inphi,outphi,innerRadius,outerRadius);
 
  if (lengthFractionInBadSectors>fMaxBadLengthFraction)
  {
    //printf("%%%%%%%% %s kChamberLowGain\n",(layer==1)?"IROC":"OROC");
    return kChamberLowGain;
  }
 
  return kChamberHighGain;
}


//_____________________________________________________________________________
Float_t AliTPCPIDResponse::MaxClusterRadius(const AliVTrack* track) const
{
  //return the radius of the outermost padrow containing a cluster in TPC
  //for the track
  const TBits* clusterMap=track->GetTPCClusterMapPtr();
  if (!clusterMap) return 0.;

  //from AliTPCParam, radius of first IROC row
  const Float_t rfirstIROC = 8.52249984741210938e+01;
  const Float_t padrowHeightIROC = 0.75;
  const Float_t rfirstOROC0 = 1.35100006103515625e+02;
  const Float_t padrowHeightOROC0 = 1.0;
  const Float_t rfirstOROC1 = 1.99350006103515625e+02;
  const Float_t padrowHeightOROC1 = 1.5;

  Int_t maxPadRow=160;
  while ((--maxPadRow)>0 && !clusterMap->TestBitNumber(maxPadRow)){}
  if (maxPadRow>126) return rfirstOROC1+(maxPadRow-126-1)*padrowHeightOROC1;
  if (maxPadRow>62) return rfirstOROC0+(maxPadRow-62-1)*padrowHeightOROC0;
  if (maxPadRow>0) return rfirstIROC+(maxPadRow-1)*padrowHeightIROC;
  return 0.0;
}


//_____________________________________________________________________________
Bool_t AliTPCPIDResponse::TrackApex(const AliVTrack* track, Float_t magField, Double_t position[3]) const
{
  //calculate the coordinates of the apex of the track
  Double_t x[3];
  track->GetXYZ(x);
  Double_t p[3];
  track->GetPxPyPz(p);
  Double_t r = 1./track->OneOverPt()/0.0299792458/magField; //signed - will determine the direction of b
  //printf("b: %.2f, x:%.2f, y:%.2f, pt: %.2f, px:%.2f, py%.2f, r: %.2f\n",magField, x[0],x[1],track->Pt(), p[0],p[1],r);
  //find orthogonal vector (Gram-Schmidt)
  Double_t alpha = (p[0]*x[0] + p[1]*x[1])/(p[0]*p[0] + p[1]*p[1]);
  Double_t b[2];
  b[0]=x[0]-alpha*p[0];
  b[1]=x[1]-alpha*p[1];
 
  Double_t norm = TMath::Sqrt(b[0]*b[0]+b[1]*b[1]);
  if (TMath::AreEqualAbs(norm,0.0,1e-10)) return kFALSE;
  b[0]/=norm;
  b[1]/=norm;
  b[0]*=r;
  b[1]*=r;
  b[0]+=x[0];
  b[1]+=x[1];
  //printf("center: x:%.2f, y:%.2f\n",b[0],b[1]);
 
  norm = TMath::Sqrt(b[0]*b[0]+b[1]*b[1]);
  if (TMath::AreEqualAbs(norm,0.0,1e-10)) return kFALSE;
 
  position[0]=b[0]+b[0]*TMath::Abs(r)/norm;
  position[1]=b[1]+b[1]*TMath::Abs(r)/norm;
  position[2]=0.;
  return kTRUE;
}

Double_t AliTPCPIDResponse::EvaldEdxSpline(Double_t bg,Int_t entry){
  //
  // Evaluate the dEdx response for given entry
  //
  TSpline * spline = (TSpline*)fSplineArray.At(entry);
  if (spline) return spline->Eval(bg);
  return 0;
}


Bool_t   AliTPCPIDResponse::RegisterSpline(const char * name, Int_t index){
  //
  // register spline to be used for drawing comparisons
  // 
  TFile * fTPCBB = TFile::Open("$ALICE_ROOT/OADB/COMMON/PID/data/TPCPIDResponse.root");
  TObjArray  *arrayTPCPID= (TObjArray*)  fTPCBB->Get("TPCPIDResponse");
  if (fSplineArray.GetEntriesFast()<index) fSplineArray.Expand(index*2);
  TSpline3 *spline=0;
  if (arrayTPCPID){
    spline = (TSpline3*)arrayTPCPID->FindObject(name);
    if (spline) fSplineArray.AddAt(spline->Clone(),index);    
  }
  delete arrayTPCPID;
  delete fTPCBB;
  return (spline!=0);
}
 AliTPCPIDResponse.cxx:1
 AliTPCPIDResponse.cxx:2
 AliTPCPIDResponse.cxx:3
 AliTPCPIDResponse.cxx:4
 AliTPCPIDResponse.cxx:5
 AliTPCPIDResponse.cxx:6
 AliTPCPIDResponse.cxx:7
 AliTPCPIDResponse.cxx:8
 AliTPCPIDResponse.cxx:9
 AliTPCPIDResponse.cxx:10
 AliTPCPIDResponse.cxx:11
 AliTPCPIDResponse.cxx:12
 AliTPCPIDResponse.cxx:13
 AliTPCPIDResponse.cxx:14
 AliTPCPIDResponse.cxx:15
 AliTPCPIDResponse.cxx:16
 AliTPCPIDResponse.cxx:17
 AliTPCPIDResponse.cxx:18
 AliTPCPIDResponse.cxx:19
 AliTPCPIDResponse.cxx:20
 AliTPCPIDResponse.cxx:21
 AliTPCPIDResponse.cxx:22
 AliTPCPIDResponse.cxx:23
 AliTPCPIDResponse.cxx:24
 AliTPCPIDResponse.cxx:25
 AliTPCPIDResponse.cxx:26
 AliTPCPIDResponse.cxx:27
 AliTPCPIDResponse.cxx:28
 AliTPCPIDResponse.cxx:29
 AliTPCPIDResponse.cxx:30
 AliTPCPIDResponse.cxx:31
 AliTPCPIDResponse.cxx:32
 AliTPCPIDResponse.cxx:33
 AliTPCPIDResponse.cxx:34
 AliTPCPIDResponse.cxx:35
 AliTPCPIDResponse.cxx:36
 AliTPCPIDResponse.cxx:37
 AliTPCPIDResponse.cxx:38
 AliTPCPIDResponse.cxx:39
 AliTPCPIDResponse.cxx:40
 AliTPCPIDResponse.cxx:41
 AliTPCPIDResponse.cxx:42
 AliTPCPIDResponse.cxx:43
 AliTPCPIDResponse.cxx:44
 AliTPCPIDResponse.cxx:45
 AliTPCPIDResponse.cxx:46
 AliTPCPIDResponse.cxx:47
 AliTPCPIDResponse.cxx:48
 AliTPCPIDResponse.cxx:49
 AliTPCPIDResponse.cxx:50
 AliTPCPIDResponse.cxx:51
 AliTPCPIDResponse.cxx:52
 AliTPCPIDResponse.cxx:53
 AliTPCPIDResponse.cxx:54
 AliTPCPIDResponse.cxx:55
 AliTPCPIDResponse.cxx:56
 AliTPCPIDResponse.cxx:57
 AliTPCPIDResponse.cxx:58
 AliTPCPIDResponse.cxx:59
 AliTPCPIDResponse.cxx:60
 AliTPCPIDResponse.cxx:61
 AliTPCPIDResponse.cxx:62
 AliTPCPIDResponse.cxx:63
 AliTPCPIDResponse.cxx:64
 AliTPCPIDResponse.cxx:65
 AliTPCPIDResponse.cxx:66
 AliTPCPIDResponse.cxx:67
 AliTPCPIDResponse.cxx:68
 AliTPCPIDResponse.cxx:69
 AliTPCPIDResponse.cxx:70
 AliTPCPIDResponse.cxx:71
 AliTPCPIDResponse.cxx:72
 AliTPCPIDResponse.cxx:73
 AliTPCPIDResponse.cxx:74
 AliTPCPIDResponse.cxx:75
 AliTPCPIDResponse.cxx:76
 AliTPCPIDResponse.cxx:77
 AliTPCPIDResponse.cxx:78
 AliTPCPIDResponse.cxx:79
 AliTPCPIDResponse.cxx:80
 AliTPCPIDResponse.cxx:81
 AliTPCPIDResponse.cxx:82
 AliTPCPIDResponse.cxx:83
 AliTPCPIDResponse.cxx:84
 AliTPCPIDResponse.cxx:85
 AliTPCPIDResponse.cxx:86
 AliTPCPIDResponse.cxx:87
 AliTPCPIDResponse.cxx:88
 AliTPCPIDResponse.cxx:89
 AliTPCPIDResponse.cxx:90
 AliTPCPIDResponse.cxx:91
 AliTPCPIDResponse.cxx:92
 AliTPCPIDResponse.cxx:93
 AliTPCPIDResponse.cxx:94
 AliTPCPIDResponse.cxx:95
 AliTPCPIDResponse.cxx:96
 AliTPCPIDResponse.cxx:97
 AliTPCPIDResponse.cxx:98
 AliTPCPIDResponse.cxx:99
 AliTPCPIDResponse.cxx:100
 AliTPCPIDResponse.cxx:101
 AliTPCPIDResponse.cxx:102
 AliTPCPIDResponse.cxx:103
 AliTPCPIDResponse.cxx:104
 AliTPCPIDResponse.cxx:105
 AliTPCPIDResponse.cxx:106
 AliTPCPIDResponse.cxx:107
 AliTPCPIDResponse.cxx:108
 AliTPCPIDResponse.cxx:109
 AliTPCPIDResponse.cxx:110
 AliTPCPIDResponse.cxx:111
 AliTPCPIDResponse.cxx:112
 AliTPCPIDResponse.cxx:113
 AliTPCPIDResponse.cxx:114
 AliTPCPIDResponse.cxx:115
 AliTPCPIDResponse.cxx:116
 AliTPCPIDResponse.cxx:117
 AliTPCPIDResponse.cxx:118
 AliTPCPIDResponse.cxx:119
 AliTPCPIDResponse.cxx:120
 AliTPCPIDResponse.cxx:121
 AliTPCPIDResponse.cxx:122
 AliTPCPIDResponse.cxx:123
 AliTPCPIDResponse.cxx:124
 AliTPCPIDResponse.cxx:125
 AliTPCPIDResponse.cxx:126
 AliTPCPIDResponse.cxx:127
 AliTPCPIDResponse.cxx:128
 AliTPCPIDResponse.cxx:129
 AliTPCPIDResponse.cxx:130
 AliTPCPIDResponse.cxx:131
 AliTPCPIDResponse.cxx:132
 AliTPCPIDResponse.cxx:133
 AliTPCPIDResponse.cxx:134
 AliTPCPIDResponse.cxx:135
 AliTPCPIDResponse.cxx:136
 AliTPCPIDResponse.cxx:137
 AliTPCPIDResponse.cxx:138
 AliTPCPIDResponse.cxx:139
 AliTPCPIDResponse.cxx:140
 AliTPCPIDResponse.cxx:141
 AliTPCPIDResponse.cxx:142
 AliTPCPIDResponse.cxx:143
 AliTPCPIDResponse.cxx:144
 AliTPCPIDResponse.cxx:145
 AliTPCPIDResponse.cxx:146
 AliTPCPIDResponse.cxx:147
 AliTPCPIDResponse.cxx:148
 AliTPCPIDResponse.cxx:149
 AliTPCPIDResponse.cxx:150
 AliTPCPIDResponse.cxx:151
 AliTPCPIDResponse.cxx:152
 AliTPCPIDResponse.cxx:153
 AliTPCPIDResponse.cxx:154
 AliTPCPIDResponse.cxx:155
 AliTPCPIDResponse.cxx:156
 AliTPCPIDResponse.cxx:157
 AliTPCPIDResponse.cxx:158
 AliTPCPIDResponse.cxx:159
 AliTPCPIDResponse.cxx:160
 AliTPCPIDResponse.cxx:161
 AliTPCPIDResponse.cxx:162
 AliTPCPIDResponse.cxx:163
 AliTPCPIDResponse.cxx:164
 AliTPCPIDResponse.cxx:165
 AliTPCPIDResponse.cxx:166
 AliTPCPIDResponse.cxx:167
 AliTPCPIDResponse.cxx:168
 AliTPCPIDResponse.cxx:169
 AliTPCPIDResponse.cxx:170
 AliTPCPIDResponse.cxx:171
 AliTPCPIDResponse.cxx:172
 AliTPCPIDResponse.cxx:173
 AliTPCPIDResponse.cxx:174
 AliTPCPIDResponse.cxx:175
 AliTPCPIDResponse.cxx:176
 AliTPCPIDResponse.cxx:177
 AliTPCPIDResponse.cxx:178
 AliTPCPIDResponse.cxx:179
 AliTPCPIDResponse.cxx:180
 AliTPCPIDResponse.cxx:181
 AliTPCPIDResponse.cxx:182
 AliTPCPIDResponse.cxx:183
 AliTPCPIDResponse.cxx:184
 AliTPCPIDResponse.cxx:185
 AliTPCPIDResponse.cxx:186
 AliTPCPIDResponse.cxx:187
 AliTPCPIDResponse.cxx:188
 AliTPCPIDResponse.cxx:189
 AliTPCPIDResponse.cxx:190
 AliTPCPIDResponse.cxx:191
 AliTPCPIDResponse.cxx:192
 AliTPCPIDResponse.cxx:193
 AliTPCPIDResponse.cxx:194
 AliTPCPIDResponse.cxx:195
 AliTPCPIDResponse.cxx:196
 AliTPCPIDResponse.cxx:197
 AliTPCPIDResponse.cxx:198
 AliTPCPIDResponse.cxx:199
 AliTPCPIDResponse.cxx:200
 AliTPCPIDResponse.cxx:201
 AliTPCPIDResponse.cxx:202
 AliTPCPIDResponse.cxx:203
 AliTPCPIDResponse.cxx:204
 AliTPCPIDResponse.cxx:205
 AliTPCPIDResponse.cxx:206
 AliTPCPIDResponse.cxx:207
 AliTPCPIDResponse.cxx:208
 AliTPCPIDResponse.cxx:209
 AliTPCPIDResponse.cxx:210
 AliTPCPIDResponse.cxx:211
 AliTPCPIDResponse.cxx:212
 AliTPCPIDResponse.cxx:213
 AliTPCPIDResponse.cxx:214
 AliTPCPIDResponse.cxx:215
 AliTPCPIDResponse.cxx:216
 AliTPCPIDResponse.cxx:217
 AliTPCPIDResponse.cxx:218
 AliTPCPIDResponse.cxx:219
 AliTPCPIDResponse.cxx:220
 AliTPCPIDResponse.cxx:221
 AliTPCPIDResponse.cxx:222
 AliTPCPIDResponse.cxx:223
 AliTPCPIDResponse.cxx:224
 AliTPCPIDResponse.cxx:225
 AliTPCPIDResponse.cxx:226
 AliTPCPIDResponse.cxx:227
 AliTPCPIDResponse.cxx:228
 AliTPCPIDResponse.cxx:229
 AliTPCPIDResponse.cxx:230
 AliTPCPIDResponse.cxx:231
 AliTPCPIDResponse.cxx:232
 AliTPCPIDResponse.cxx:233
 AliTPCPIDResponse.cxx:234
 AliTPCPIDResponse.cxx:235
 AliTPCPIDResponse.cxx:236
 AliTPCPIDResponse.cxx:237
 AliTPCPIDResponse.cxx:238
 AliTPCPIDResponse.cxx:239
 AliTPCPIDResponse.cxx:240
 AliTPCPIDResponse.cxx:241
 AliTPCPIDResponse.cxx:242
 AliTPCPIDResponse.cxx:243
 AliTPCPIDResponse.cxx:244
 AliTPCPIDResponse.cxx:245
 AliTPCPIDResponse.cxx:246
 AliTPCPIDResponse.cxx:247
 AliTPCPIDResponse.cxx:248
 AliTPCPIDResponse.cxx:249
 AliTPCPIDResponse.cxx:250
 AliTPCPIDResponse.cxx:251
 AliTPCPIDResponse.cxx:252
 AliTPCPIDResponse.cxx:253
 AliTPCPIDResponse.cxx:254
 AliTPCPIDResponse.cxx:255
 AliTPCPIDResponse.cxx:256
 AliTPCPIDResponse.cxx:257
 AliTPCPIDResponse.cxx:258
 AliTPCPIDResponse.cxx:259
 AliTPCPIDResponse.cxx:260
 AliTPCPIDResponse.cxx:261
 AliTPCPIDResponse.cxx:262
 AliTPCPIDResponse.cxx:263
 AliTPCPIDResponse.cxx:264
 AliTPCPIDResponse.cxx:265
 AliTPCPIDResponse.cxx:266
 AliTPCPIDResponse.cxx:267
 AliTPCPIDResponse.cxx:268
 AliTPCPIDResponse.cxx:269
 AliTPCPIDResponse.cxx:270
 AliTPCPIDResponse.cxx:271
 AliTPCPIDResponse.cxx:272
 AliTPCPIDResponse.cxx:273
 AliTPCPIDResponse.cxx:274
 AliTPCPIDResponse.cxx:275
 AliTPCPIDResponse.cxx:276
 AliTPCPIDResponse.cxx:277
 AliTPCPIDResponse.cxx:278
 AliTPCPIDResponse.cxx:279
 AliTPCPIDResponse.cxx:280
 AliTPCPIDResponse.cxx:281
 AliTPCPIDResponse.cxx:282
 AliTPCPIDResponse.cxx:283
 AliTPCPIDResponse.cxx:284
 AliTPCPIDResponse.cxx:285
 AliTPCPIDResponse.cxx:286
 AliTPCPIDResponse.cxx:287
 AliTPCPIDResponse.cxx:288
 AliTPCPIDResponse.cxx:289
 AliTPCPIDResponse.cxx:290
 AliTPCPIDResponse.cxx:291
 AliTPCPIDResponse.cxx:292
 AliTPCPIDResponse.cxx:293
 AliTPCPIDResponse.cxx:294
 AliTPCPIDResponse.cxx:295
 AliTPCPIDResponse.cxx:296
 AliTPCPIDResponse.cxx:297
 AliTPCPIDResponse.cxx:298
 AliTPCPIDResponse.cxx:299
 AliTPCPIDResponse.cxx:300
 AliTPCPIDResponse.cxx:301
 AliTPCPIDResponse.cxx:302
 AliTPCPIDResponse.cxx:303
 AliTPCPIDResponse.cxx:304
 AliTPCPIDResponse.cxx:305
 AliTPCPIDResponse.cxx:306
 AliTPCPIDResponse.cxx:307
 AliTPCPIDResponse.cxx:308
 AliTPCPIDResponse.cxx:309
 AliTPCPIDResponse.cxx:310
 AliTPCPIDResponse.cxx:311
 AliTPCPIDResponse.cxx:312
 AliTPCPIDResponse.cxx:313
 AliTPCPIDResponse.cxx:314
 AliTPCPIDResponse.cxx:315
 AliTPCPIDResponse.cxx:316
 AliTPCPIDResponse.cxx:317
 AliTPCPIDResponse.cxx:318
 AliTPCPIDResponse.cxx:319
 AliTPCPIDResponse.cxx:320
 AliTPCPIDResponse.cxx:321
 AliTPCPIDResponse.cxx:322
 AliTPCPIDResponse.cxx:323
 AliTPCPIDResponse.cxx:324
 AliTPCPIDResponse.cxx:325
 AliTPCPIDResponse.cxx:326
 AliTPCPIDResponse.cxx:327
 AliTPCPIDResponse.cxx:328
 AliTPCPIDResponse.cxx:329
 AliTPCPIDResponse.cxx:330
 AliTPCPIDResponse.cxx:331
 AliTPCPIDResponse.cxx:332
 AliTPCPIDResponse.cxx:333
 AliTPCPIDResponse.cxx:334
 AliTPCPIDResponse.cxx:335
 AliTPCPIDResponse.cxx:336
 AliTPCPIDResponse.cxx:337
 AliTPCPIDResponse.cxx:338
 AliTPCPIDResponse.cxx:339
 AliTPCPIDResponse.cxx:340
 AliTPCPIDResponse.cxx:341
 AliTPCPIDResponse.cxx:342
 AliTPCPIDResponse.cxx:343
 AliTPCPIDResponse.cxx:344
 AliTPCPIDResponse.cxx:345
 AliTPCPIDResponse.cxx:346
 AliTPCPIDResponse.cxx:347
 AliTPCPIDResponse.cxx:348
 AliTPCPIDResponse.cxx:349
 AliTPCPIDResponse.cxx:350
 AliTPCPIDResponse.cxx:351
 AliTPCPIDResponse.cxx:352
 AliTPCPIDResponse.cxx:353
 AliTPCPIDResponse.cxx:354
 AliTPCPIDResponse.cxx:355
 AliTPCPIDResponse.cxx:356
 AliTPCPIDResponse.cxx:357
 AliTPCPIDResponse.cxx:358
 AliTPCPIDResponse.cxx:359
 AliTPCPIDResponse.cxx:360
 AliTPCPIDResponse.cxx:361
 AliTPCPIDResponse.cxx:362
 AliTPCPIDResponse.cxx:363
 AliTPCPIDResponse.cxx:364
 AliTPCPIDResponse.cxx:365
 AliTPCPIDResponse.cxx:366
 AliTPCPIDResponse.cxx:367
 AliTPCPIDResponse.cxx:368
 AliTPCPIDResponse.cxx:369
 AliTPCPIDResponse.cxx:370
 AliTPCPIDResponse.cxx:371
 AliTPCPIDResponse.cxx:372
 AliTPCPIDResponse.cxx:373
 AliTPCPIDResponse.cxx:374
 AliTPCPIDResponse.cxx:375
 AliTPCPIDResponse.cxx:376
 AliTPCPIDResponse.cxx:377
 AliTPCPIDResponse.cxx:378
 AliTPCPIDResponse.cxx:379
 AliTPCPIDResponse.cxx:380
 AliTPCPIDResponse.cxx:381
 AliTPCPIDResponse.cxx:382
 AliTPCPIDResponse.cxx:383
 AliTPCPIDResponse.cxx:384
 AliTPCPIDResponse.cxx:385
 AliTPCPIDResponse.cxx:386
 AliTPCPIDResponse.cxx:387
 AliTPCPIDResponse.cxx:388
 AliTPCPIDResponse.cxx:389
 AliTPCPIDResponse.cxx:390
 AliTPCPIDResponse.cxx:391
 AliTPCPIDResponse.cxx:392
 AliTPCPIDResponse.cxx:393
 AliTPCPIDResponse.cxx:394
 AliTPCPIDResponse.cxx:395
 AliTPCPIDResponse.cxx:396
 AliTPCPIDResponse.cxx:397
 AliTPCPIDResponse.cxx:398
 AliTPCPIDResponse.cxx:399
 AliTPCPIDResponse.cxx:400
 AliTPCPIDResponse.cxx:401
 AliTPCPIDResponse.cxx:402
 AliTPCPIDResponse.cxx:403
 AliTPCPIDResponse.cxx:404
 AliTPCPIDResponse.cxx:405
 AliTPCPIDResponse.cxx:406
 AliTPCPIDResponse.cxx:407
 AliTPCPIDResponse.cxx:408
 AliTPCPIDResponse.cxx:409
 AliTPCPIDResponse.cxx:410
 AliTPCPIDResponse.cxx:411
 AliTPCPIDResponse.cxx:412
 AliTPCPIDResponse.cxx:413
 AliTPCPIDResponse.cxx:414
 AliTPCPIDResponse.cxx:415
 AliTPCPIDResponse.cxx:416
 AliTPCPIDResponse.cxx:417
 AliTPCPIDResponse.cxx:418
 AliTPCPIDResponse.cxx:419
 AliTPCPIDResponse.cxx:420
 AliTPCPIDResponse.cxx:421
 AliTPCPIDResponse.cxx:422
 AliTPCPIDResponse.cxx:423
 AliTPCPIDResponse.cxx:424
 AliTPCPIDResponse.cxx:425
 AliTPCPIDResponse.cxx:426
 AliTPCPIDResponse.cxx:427
 AliTPCPIDResponse.cxx:428
 AliTPCPIDResponse.cxx:429
 AliTPCPIDResponse.cxx:430
 AliTPCPIDResponse.cxx:431
 AliTPCPIDResponse.cxx:432
 AliTPCPIDResponse.cxx:433
 AliTPCPIDResponse.cxx:434
 AliTPCPIDResponse.cxx:435
 AliTPCPIDResponse.cxx:436
 AliTPCPIDResponse.cxx:437
 AliTPCPIDResponse.cxx:438
 AliTPCPIDResponse.cxx:439
 AliTPCPIDResponse.cxx:440
 AliTPCPIDResponse.cxx:441
 AliTPCPIDResponse.cxx:442
 AliTPCPIDResponse.cxx:443
 AliTPCPIDResponse.cxx:444
 AliTPCPIDResponse.cxx:445
 AliTPCPIDResponse.cxx:446
 AliTPCPIDResponse.cxx:447
 AliTPCPIDResponse.cxx:448
 AliTPCPIDResponse.cxx:449
 AliTPCPIDResponse.cxx:450
 AliTPCPIDResponse.cxx:451
 AliTPCPIDResponse.cxx:452
 AliTPCPIDResponse.cxx:453
 AliTPCPIDResponse.cxx:454
 AliTPCPIDResponse.cxx:455
 AliTPCPIDResponse.cxx:456
 AliTPCPIDResponse.cxx:457
 AliTPCPIDResponse.cxx:458
 AliTPCPIDResponse.cxx:459
 AliTPCPIDResponse.cxx:460
 AliTPCPIDResponse.cxx:461
 AliTPCPIDResponse.cxx:462
 AliTPCPIDResponse.cxx:463
 AliTPCPIDResponse.cxx:464
 AliTPCPIDResponse.cxx:465
 AliTPCPIDResponse.cxx:466
 AliTPCPIDResponse.cxx:467
 AliTPCPIDResponse.cxx:468
 AliTPCPIDResponse.cxx:469
 AliTPCPIDResponse.cxx:470
 AliTPCPIDResponse.cxx:471
 AliTPCPIDResponse.cxx:472
 AliTPCPIDResponse.cxx:473
 AliTPCPIDResponse.cxx:474
 AliTPCPIDResponse.cxx:475
 AliTPCPIDResponse.cxx:476
 AliTPCPIDResponse.cxx:477
 AliTPCPIDResponse.cxx:478
 AliTPCPIDResponse.cxx:479
 AliTPCPIDResponse.cxx:480
 AliTPCPIDResponse.cxx:481
 AliTPCPIDResponse.cxx:482
 AliTPCPIDResponse.cxx:483
 AliTPCPIDResponse.cxx:484
 AliTPCPIDResponse.cxx:485
 AliTPCPIDResponse.cxx:486
 AliTPCPIDResponse.cxx:487
 AliTPCPIDResponse.cxx:488
 AliTPCPIDResponse.cxx:489
 AliTPCPIDResponse.cxx:490
 AliTPCPIDResponse.cxx:491
 AliTPCPIDResponse.cxx:492
 AliTPCPIDResponse.cxx:493
 AliTPCPIDResponse.cxx:494
 AliTPCPIDResponse.cxx:495
 AliTPCPIDResponse.cxx:496
 AliTPCPIDResponse.cxx:497
 AliTPCPIDResponse.cxx:498
 AliTPCPIDResponse.cxx:499
 AliTPCPIDResponse.cxx:500
 AliTPCPIDResponse.cxx:501
 AliTPCPIDResponse.cxx:502
 AliTPCPIDResponse.cxx:503
 AliTPCPIDResponse.cxx:504
 AliTPCPIDResponse.cxx:505
 AliTPCPIDResponse.cxx:506
 AliTPCPIDResponse.cxx:507
 AliTPCPIDResponse.cxx:508
 AliTPCPIDResponse.cxx:509
 AliTPCPIDResponse.cxx:510
 AliTPCPIDResponse.cxx:511
 AliTPCPIDResponse.cxx:512
 AliTPCPIDResponse.cxx:513
 AliTPCPIDResponse.cxx:514
 AliTPCPIDResponse.cxx:515
 AliTPCPIDResponse.cxx:516
 AliTPCPIDResponse.cxx:517
 AliTPCPIDResponse.cxx:518
 AliTPCPIDResponse.cxx:519
 AliTPCPIDResponse.cxx:520
 AliTPCPIDResponse.cxx:521
 AliTPCPIDResponse.cxx:522
 AliTPCPIDResponse.cxx:523
 AliTPCPIDResponse.cxx:524
 AliTPCPIDResponse.cxx:525
 AliTPCPIDResponse.cxx:526
 AliTPCPIDResponse.cxx:527
 AliTPCPIDResponse.cxx:528
 AliTPCPIDResponse.cxx:529
 AliTPCPIDResponse.cxx:530
 AliTPCPIDResponse.cxx:531
 AliTPCPIDResponse.cxx:532
 AliTPCPIDResponse.cxx:533
 AliTPCPIDResponse.cxx:534
 AliTPCPIDResponse.cxx:535
 AliTPCPIDResponse.cxx:536
 AliTPCPIDResponse.cxx:537
 AliTPCPIDResponse.cxx:538
 AliTPCPIDResponse.cxx:539
 AliTPCPIDResponse.cxx:540
 AliTPCPIDResponse.cxx:541
 AliTPCPIDResponse.cxx:542
 AliTPCPIDResponse.cxx:543
 AliTPCPIDResponse.cxx:544
 AliTPCPIDResponse.cxx:545
 AliTPCPIDResponse.cxx:546
 AliTPCPIDResponse.cxx:547
 AliTPCPIDResponse.cxx:548
 AliTPCPIDResponse.cxx:549
 AliTPCPIDResponse.cxx:550
 AliTPCPIDResponse.cxx:551
 AliTPCPIDResponse.cxx:552
 AliTPCPIDResponse.cxx:553
 AliTPCPIDResponse.cxx:554
 AliTPCPIDResponse.cxx:555
 AliTPCPIDResponse.cxx:556
 AliTPCPIDResponse.cxx:557
 AliTPCPIDResponse.cxx:558
 AliTPCPIDResponse.cxx:559
 AliTPCPIDResponse.cxx:560
 AliTPCPIDResponse.cxx:561
 AliTPCPIDResponse.cxx:562
 AliTPCPIDResponse.cxx:563
 AliTPCPIDResponse.cxx:564
 AliTPCPIDResponse.cxx:565
 AliTPCPIDResponse.cxx:566
 AliTPCPIDResponse.cxx:567
 AliTPCPIDResponse.cxx:568
 AliTPCPIDResponse.cxx:569
 AliTPCPIDResponse.cxx:570
 AliTPCPIDResponse.cxx:571
 AliTPCPIDResponse.cxx:572
 AliTPCPIDResponse.cxx:573
 AliTPCPIDResponse.cxx:574
 AliTPCPIDResponse.cxx:575
 AliTPCPIDResponse.cxx:576
 AliTPCPIDResponse.cxx:577
 AliTPCPIDResponse.cxx:578
 AliTPCPIDResponse.cxx:579
 AliTPCPIDResponse.cxx:580
 AliTPCPIDResponse.cxx:581
 AliTPCPIDResponse.cxx:582
 AliTPCPIDResponse.cxx:583
 AliTPCPIDResponse.cxx:584
 AliTPCPIDResponse.cxx:585
 AliTPCPIDResponse.cxx:586
 AliTPCPIDResponse.cxx:587
 AliTPCPIDResponse.cxx:588
 AliTPCPIDResponse.cxx:589
 AliTPCPIDResponse.cxx:590
 AliTPCPIDResponse.cxx:591
 AliTPCPIDResponse.cxx:592
 AliTPCPIDResponse.cxx:593
 AliTPCPIDResponse.cxx:594
 AliTPCPIDResponse.cxx:595
 AliTPCPIDResponse.cxx:596
 AliTPCPIDResponse.cxx:597
 AliTPCPIDResponse.cxx:598
 AliTPCPIDResponse.cxx:599
 AliTPCPIDResponse.cxx:600
 AliTPCPIDResponse.cxx:601
 AliTPCPIDResponse.cxx:602
 AliTPCPIDResponse.cxx:603
 AliTPCPIDResponse.cxx:604
 AliTPCPIDResponse.cxx:605
 AliTPCPIDResponse.cxx:606
 AliTPCPIDResponse.cxx:607
 AliTPCPIDResponse.cxx:608
 AliTPCPIDResponse.cxx:609
 AliTPCPIDResponse.cxx:610
 AliTPCPIDResponse.cxx:611
 AliTPCPIDResponse.cxx:612
 AliTPCPIDResponse.cxx:613
 AliTPCPIDResponse.cxx:614
 AliTPCPIDResponse.cxx:615
 AliTPCPIDResponse.cxx:616
 AliTPCPIDResponse.cxx:617
 AliTPCPIDResponse.cxx:618
 AliTPCPIDResponse.cxx:619
 AliTPCPIDResponse.cxx:620
 AliTPCPIDResponse.cxx:621
 AliTPCPIDResponse.cxx:622
 AliTPCPIDResponse.cxx:623
 AliTPCPIDResponse.cxx:624
 AliTPCPIDResponse.cxx:625
 AliTPCPIDResponse.cxx:626
 AliTPCPIDResponse.cxx:627
 AliTPCPIDResponse.cxx:628
 AliTPCPIDResponse.cxx:629
 AliTPCPIDResponse.cxx:630
 AliTPCPIDResponse.cxx:631
 AliTPCPIDResponse.cxx:632
 AliTPCPIDResponse.cxx:633
 AliTPCPIDResponse.cxx:634
 AliTPCPIDResponse.cxx:635
 AliTPCPIDResponse.cxx:636
 AliTPCPIDResponse.cxx:637
 AliTPCPIDResponse.cxx:638
 AliTPCPIDResponse.cxx:639
 AliTPCPIDResponse.cxx:640
 AliTPCPIDResponse.cxx:641
 AliTPCPIDResponse.cxx:642
 AliTPCPIDResponse.cxx:643
 AliTPCPIDResponse.cxx:644
 AliTPCPIDResponse.cxx:645
 AliTPCPIDResponse.cxx:646
 AliTPCPIDResponse.cxx:647
 AliTPCPIDResponse.cxx:648
 AliTPCPIDResponse.cxx:649
 AliTPCPIDResponse.cxx:650
 AliTPCPIDResponse.cxx:651
 AliTPCPIDResponse.cxx:652
 AliTPCPIDResponse.cxx:653
 AliTPCPIDResponse.cxx:654
 AliTPCPIDResponse.cxx:655
 AliTPCPIDResponse.cxx:656
 AliTPCPIDResponse.cxx:657
 AliTPCPIDResponse.cxx:658
 AliTPCPIDResponse.cxx:659
 AliTPCPIDResponse.cxx:660
 AliTPCPIDResponse.cxx:661
 AliTPCPIDResponse.cxx:662
 AliTPCPIDResponse.cxx:663
 AliTPCPIDResponse.cxx:664
 AliTPCPIDResponse.cxx:665
 AliTPCPIDResponse.cxx:666
 AliTPCPIDResponse.cxx:667
 AliTPCPIDResponse.cxx:668
 AliTPCPIDResponse.cxx:669
 AliTPCPIDResponse.cxx:670
 AliTPCPIDResponse.cxx:671
 AliTPCPIDResponse.cxx:672
 AliTPCPIDResponse.cxx:673
 AliTPCPIDResponse.cxx:674
 AliTPCPIDResponse.cxx:675
 AliTPCPIDResponse.cxx:676
 AliTPCPIDResponse.cxx:677
 AliTPCPIDResponse.cxx:678
 AliTPCPIDResponse.cxx:679
 AliTPCPIDResponse.cxx:680
 AliTPCPIDResponse.cxx:681
 AliTPCPIDResponse.cxx:682
 AliTPCPIDResponse.cxx:683
 AliTPCPIDResponse.cxx:684
 AliTPCPIDResponse.cxx:685
 AliTPCPIDResponse.cxx:686
 AliTPCPIDResponse.cxx:687
 AliTPCPIDResponse.cxx:688
 AliTPCPIDResponse.cxx:689
 AliTPCPIDResponse.cxx:690
 AliTPCPIDResponse.cxx:691
 AliTPCPIDResponse.cxx:692
 AliTPCPIDResponse.cxx:693
 AliTPCPIDResponse.cxx:694
 AliTPCPIDResponse.cxx:695
 AliTPCPIDResponse.cxx:696
 AliTPCPIDResponse.cxx:697
 AliTPCPIDResponse.cxx:698
 AliTPCPIDResponse.cxx:699
 AliTPCPIDResponse.cxx:700
 AliTPCPIDResponse.cxx:701
 AliTPCPIDResponse.cxx:702
 AliTPCPIDResponse.cxx:703
 AliTPCPIDResponse.cxx:704
 AliTPCPIDResponse.cxx:705
 AliTPCPIDResponse.cxx:706
 AliTPCPIDResponse.cxx:707
 AliTPCPIDResponse.cxx:708
 AliTPCPIDResponse.cxx:709
 AliTPCPIDResponse.cxx:710
 AliTPCPIDResponse.cxx:711
 AliTPCPIDResponse.cxx:712
 AliTPCPIDResponse.cxx:713
 AliTPCPIDResponse.cxx:714
 AliTPCPIDResponse.cxx:715
 AliTPCPIDResponse.cxx:716
 AliTPCPIDResponse.cxx:717
 AliTPCPIDResponse.cxx:718
 AliTPCPIDResponse.cxx:719
 AliTPCPIDResponse.cxx:720
 AliTPCPIDResponse.cxx:721
 AliTPCPIDResponse.cxx:722
 AliTPCPIDResponse.cxx:723
 AliTPCPIDResponse.cxx:724
 AliTPCPIDResponse.cxx:725
 AliTPCPIDResponse.cxx:726
 AliTPCPIDResponse.cxx:727
 AliTPCPIDResponse.cxx:728
 AliTPCPIDResponse.cxx:729
 AliTPCPIDResponse.cxx:730
 AliTPCPIDResponse.cxx:731
 AliTPCPIDResponse.cxx:732
 AliTPCPIDResponse.cxx:733
 AliTPCPIDResponse.cxx:734
 AliTPCPIDResponse.cxx:735
 AliTPCPIDResponse.cxx:736
 AliTPCPIDResponse.cxx:737
 AliTPCPIDResponse.cxx:738
 AliTPCPIDResponse.cxx:739
 AliTPCPIDResponse.cxx:740
 AliTPCPIDResponse.cxx:741
 AliTPCPIDResponse.cxx:742
 AliTPCPIDResponse.cxx:743
 AliTPCPIDResponse.cxx:744
 AliTPCPIDResponse.cxx:745
 AliTPCPIDResponse.cxx:746
 AliTPCPIDResponse.cxx:747
 AliTPCPIDResponse.cxx:748
 AliTPCPIDResponse.cxx:749
 AliTPCPIDResponse.cxx:750
 AliTPCPIDResponse.cxx:751
 AliTPCPIDResponse.cxx:752
 AliTPCPIDResponse.cxx:753
 AliTPCPIDResponse.cxx:754
 AliTPCPIDResponse.cxx:755
 AliTPCPIDResponse.cxx:756
 AliTPCPIDResponse.cxx:757
 AliTPCPIDResponse.cxx:758
 AliTPCPIDResponse.cxx:759
 AliTPCPIDResponse.cxx:760
 AliTPCPIDResponse.cxx:761
 AliTPCPIDResponse.cxx:762
 AliTPCPIDResponse.cxx:763
 AliTPCPIDResponse.cxx:764
 AliTPCPIDResponse.cxx:765
 AliTPCPIDResponse.cxx:766
 AliTPCPIDResponse.cxx:767
 AliTPCPIDResponse.cxx:768
 AliTPCPIDResponse.cxx:769
 AliTPCPIDResponse.cxx:770
 AliTPCPIDResponse.cxx:771
 AliTPCPIDResponse.cxx:772
 AliTPCPIDResponse.cxx:773
 AliTPCPIDResponse.cxx:774
 AliTPCPIDResponse.cxx:775
 AliTPCPIDResponse.cxx:776
 AliTPCPIDResponse.cxx:777
 AliTPCPIDResponse.cxx:778
 AliTPCPIDResponse.cxx:779
 AliTPCPIDResponse.cxx:780
 AliTPCPIDResponse.cxx:781
 AliTPCPIDResponse.cxx:782
 AliTPCPIDResponse.cxx:783
 AliTPCPIDResponse.cxx:784
 AliTPCPIDResponse.cxx:785
 AliTPCPIDResponse.cxx:786
 AliTPCPIDResponse.cxx:787
 AliTPCPIDResponse.cxx:788
 AliTPCPIDResponse.cxx:789
 AliTPCPIDResponse.cxx:790
 AliTPCPIDResponse.cxx:791
 AliTPCPIDResponse.cxx:792
 AliTPCPIDResponse.cxx:793
 AliTPCPIDResponse.cxx:794
 AliTPCPIDResponse.cxx:795
 AliTPCPIDResponse.cxx:796
 AliTPCPIDResponse.cxx:797
 AliTPCPIDResponse.cxx:798
 AliTPCPIDResponse.cxx:799
 AliTPCPIDResponse.cxx:800
 AliTPCPIDResponse.cxx:801
 AliTPCPIDResponse.cxx:802
 AliTPCPIDResponse.cxx:803
 AliTPCPIDResponse.cxx:804
 AliTPCPIDResponse.cxx:805
 AliTPCPIDResponse.cxx:806
 AliTPCPIDResponse.cxx:807
 AliTPCPIDResponse.cxx:808
 AliTPCPIDResponse.cxx:809
 AliTPCPIDResponse.cxx:810
 AliTPCPIDResponse.cxx:811
 AliTPCPIDResponse.cxx:812
 AliTPCPIDResponse.cxx:813
 AliTPCPIDResponse.cxx:814
 AliTPCPIDResponse.cxx:815
 AliTPCPIDResponse.cxx:816
 AliTPCPIDResponse.cxx:817
 AliTPCPIDResponse.cxx:818
 AliTPCPIDResponse.cxx:819
 AliTPCPIDResponse.cxx:820
 AliTPCPIDResponse.cxx:821
 AliTPCPIDResponse.cxx:822
 AliTPCPIDResponse.cxx:823
 AliTPCPIDResponse.cxx:824
 AliTPCPIDResponse.cxx:825
 AliTPCPIDResponse.cxx:826
 AliTPCPIDResponse.cxx:827
 AliTPCPIDResponse.cxx:828
 AliTPCPIDResponse.cxx:829
 AliTPCPIDResponse.cxx:830
 AliTPCPIDResponse.cxx:831
 AliTPCPIDResponse.cxx:832
 AliTPCPIDResponse.cxx:833
 AliTPCPIDResponse.cxx:834
 AliTPCPIDResponse.cxx:835
 AliTPCPIDResponse.cxx:836
 AliTPCPIDResponse.cxx:837
 AliTPCPIDResponse.cxx:838
 AliTPCPIDResponse.cxx:839
 AliTPCPIDResponse.cxx:840
 AliTPCPIDResponse.cxx:841
 AliTPCPIDResponse.cxx:842
 AliTPCPIDResponse.cxx:843
 AliTPCPIDResponse.cxx:844
 AliTPCPIDResponse.cxx:845
 AliTPCPIDResponse.cxx:846
 AliTPCPIDResponse.cxx:847
 AliTPCPIDResponse.cxx:848
 AliTPCPIDResponse.cxx:849
 AliTPCPIDResponse.cxx:850
 AliTPCPIDResponse.cxx:851
 AliTPCPIDResponse.cxx:852
 AliTPCPIDResponse.cxx:853
 AliTPCPIDResponse.cxx:854
 AliTPCPIDResponse.cxx:855
 AliTPCPIDResponse.cxx:856
 AliTPCPIDResponse.cxx:857
 AliTPCPIDResponse.cxx:858
 AliTPCPIDResponse.cxx:859
 AliTPCPIDResponse.cxx:860
 AliTPCPIDResponse.cxx:861
 AliTPCPIDResponse.cxx:862
 AliTPCPIDResponse.cxx:863
 AliTPCPIDResponse.cxx:864
 AliTPCPIDResponse.cxx:865
 AliTPCPIDResponse.cxx:866
 AliTPCPIDResponse.cxx:867
 AliTPCPIDResponse.cxx:868
 AliTPCPIDResponse.cxx:869
 AliTPCPIDResponse.cxx:870
 AliTPCPIDResponse.cxx:871
 AliTPCPIDResponse.cxx:872
 AliTPCPIDResponse.cxx:873
 AliTPCPIDResponse.cxx:874
 AliTPCPIDResponse.cxx:875
 AliTPCPIDResponse.cxx:876
 AliTPCPIDResponse.cxx:877
 AliTPCPIDResponse.cxx:878
 AliTPCPIDResponse.cxx:879
 AliTPCPIDResponse.cxx:880
 AliTPCPIDResponse.cxx:881
 AliTPCPIDResponse.cxx:882
 AliTPCPIDResponse.cxx:883
 AliTPCPIDResponse.cxx:884
 AliTPCPIDResponse.cxx:885
 AliTPCPIDResponse.cxx:886
 AliTPCPIDResponse.cxx:887
 AliTPCPIDResponse.cxx:888
 AliTPCPIDResponse.cxx:889
 AliTPCPIDResponse.cxx:890
 AliTPCPIDResponse.cxx:891
 AliTPCPIDResponse.cxx:892
 AliTPCPIDResponse.cxx:893
 AliTPCPIDResponse.cxx:894
 AliTPCPIDResponse.cxx:895
 AliTPCPIDResponse.cxx:896
 AliTPCPIDResponse.cxx:897
 AliTPCPIDResponse.cxx:898
 AliTPCPIDResponse.cxx:899
 AliTPCPIDResponse.cxx:900
 AliTPCPIDResponse.cxx:901
 AliTPCPIDResponse.cxx:902
 AliTPCPIDResponse.cxx:903
 AliTPCPIDResponse.cxx:904
 AliTPCPIDResponse.cxx:905
 AliTPCPIDResponse.cxx:906
 AliTPCPIDResponse.cxx:907
 AliTPCPIDResponse.cxx:908
 AliTPCPIDResponse.cxx:909
 AliTPCPIDResponse.cxx:910
 AliTPCPIDResponse.cxx:911
 AliTPCPIDResponse.cxx:912
 AliTPCPIDResponse.cxx:913
 AliTPCPIDResponse.cxx:914
 AliTPCPIDResponse.cxx:915
 AliTPCPIDResponse.cxx:916
 AliTPCPIDResponse.cxx:917
 AliTPCPIDResponse.cxx:918
 AliTPCPIDResponse.cxx:919
 AliTPCPIDResponse.cxx:920
 AliTPCPIDResponse.cxx:921
 AliTPCPIDResponse.cxx:922
 AliTPCPIDResponse.cxx:923
 AliTPCPIDResponse.cxx:924
 AliTPCPIDResponse.cxx:925
 AliTPCPIDResponse.cxx:926
 AliTPCPIDResponse.cxx:927
 AliTPCPIDResponse.cxx:928
 AliTPCPIDResponse.cxx:929
 AliTPCPIDResponse.cxx:930
 AliTPCPIDResponse.cxx:931
 AliTPCPIDResponse.cxx:932
 AliTPCPIDResponse.cxx:933
 AliTPCPIDResponse.cxx:934
 AliTPCPIDResponse.cxx:935
 AliTPCPIDResponse.cxx:936
 AliTPCPIDResponse.cxx:937
 AliTPCPIDResponse.cxx:938
 AliTPCPIDResponse.cxx:939
 AliTPCPIDResponse.cxx:940
 AliTPCPIDResponse.cxx:941
 AliTPCPIDResponse.cxx:942
 AliTPCPIDResponse.cxx:943
 AliTPCPIDResponse.cxx:944
 AliTPCPIDResponse.cxx:945
 AliTPCPIDResponse.cxx:946
 AliTPCPIDResponse.cxx:947
 AliTPCPIDResponse.cxx:948
 AliTPCPIDResponse.cxx:949
 AliTPCPIDResponse.cxx:950
 AliTPCPIDResponse.cxx:951
 AliTPCPIDResponse.cxx:952
 AliTPCPIDResponse.cxx:953
 AliTPCPIDResponse.cxx:954
 AliTPCPIDResponse.cxx:955
 AliTPCPIDResponse.cxx:956
 AliTPCPIDResponse.cxx:957
 AliTPCPIDResponse.cxx:958
 AliTPCPIDResponse.cxx:959
 AliTPCPIDResponse.cxx:960
 AliTPCPIDResponse.cxx:961
 AliTPCPIDResponse.cxx:962
 AliTPCPIDResponse.cxx:963
 AliTPCPIDResponse.cxx:964
 AliTPCPIDResponse.cxx:965
 AliTPCPIDResponse.cxx:966
 AliTPCPIDResponse.cxx:967
 AliTPCPIDResponse.cxx:968
 AliTPCPIDResponse.cxx:969
 AliTPCPIDResponse.cxx:970
 AliTPCPIDResponse.cxx:971
 AliTPCPIDResponse.cxx:972
 AliTPCPIDResponse.cxx:973
 AliTPCPIDResponse.cxx:974
 AliTPCPIDResponse.cxx:975
 AliTPCPIDResponse.cxx:976
 AliTPCPIDResponse.cxx:977
 AliTPCPIDResponse.cxx:978
 AliTPCPIDResponse.cxx:979
 AliTPCPIDResponse.cxx:980
 AliTPCPIDResponse.cxx:981
 AliTPCPIDResponse.cxx:982
 AliTPCPIDResponse.cxx:983
 AliTPCPIDResponse.cxx:984
 AliTPCPIDResponse.cxx:985
 AliTPCPIDResponse.cxx:986
 AliTPCPIDResponse.cxx:987
 AliTPCPIDResponse.cxx:988
 AliTPCPIDResponse.cxx:989
 AliTPCPIDResponse.cxx:990
 AliTPCPIDResponse.cxx:991
 AliTPCPIDResponse.cxx:992
 AliTPCPIDResponse.cxx:993
 AliTPCPIDResponse.cxx:994
 AliTPCPIDResponse.cxx:995
 AliTPCPIDResponse.cxx:996
 AliTPCPIDResponse.cxx:997
 AliTPCPIDResponse.cxx:998
 AliTPCPIDResponse.cxx:999
 AliTPCPIDResponse.cxx:1000
 AliTPCPIDResponse.cxx:1001
 AliTPCPIDResponse.cxx:1002
 AliTPCPIDResponse.cxx:1003
 AliTPCPIDResponse.cxx:1004
 AliTPCPIDResponse.cxx:1005
 AliTPCPIDResponse.cxx:1006
 AliTPCPIDResponse.cxx:1007
 AliTPCPIDResponse.cxx:1008
 AliTPCPIDResponse.cxx:1009
 AliTPCPIDResponse.cxx:1010
 AliTPCPIDResponse.cxx:1011
 AliTPCPIDResponse.cxx:1012
 AliTPCPIDResponse.cxx:1013
 AliTPCPIDResponse.cxx:1014
 AliTPCPIDResponse.cxx:1015
 AliTPCPIDResponse.cxx:1016
 AliTPCPIDResponse.cxx:1017
 AliTPCPIDResponse.cxx:1018
 AliTPCPIDResponse.cxx:1019
 AliTPCPIDResponse.cxx:1020
 AliTPCPIDResponse.cxx:1021
 AliTPCPIDResponse.cxx:1022
 AliTPCPIDResponse.cxx:1023
 AliTPCPIDResponse.cxx:1024
 AliTPCPIDResponse.cxx:1025
 AliTPCPIDResponse.cxx:1026
 AliTPCPIDResponse.cxx:1027
 AliTPCPIDResponse.cxx:1028
 AliTPCPIDResponse.cxx:1029
 AliTPCPIDResponse.cxx:1030
 AliTPCPIDResponse.cxx:1031
 AliTPCPIDResponse.cxx:1032
 AliTPCPIDResponse.cxx:1033
 AliTPCPIDResponse.cxx:1034
 AliTPCPIDResponse.cxx:1035
 AliTPCPIDResponse.cxx:1036
 AliTPCPIDResponse.cxx:1037
 AliTPCPIDResponse.cxx:1038
 AliTPCPIDResponse.cxx:1039
 AliTPCPIDResponse.cxx:1040
 AliTPCPIDResponse.cxx:1041
 AliTPCPIDResponse.cxx:1042
 AliTPCPIDResponse.cxx:1043
 AliTPCPIDResponse.cxx:1044
 AliTPCPIDResponse.cxx:1045
 AliTPCPIDResponse.cxx:1046
 AliTPCPIDResponse.cxx:1047
 AliTPCPIDResponse.cxx:1048
 AliTPCPIDResponse.cxx:1049
 AliTPCPIDResponse.cxx:1050
 AliTPCPIDResponse.cxx:1051
 AliTPCPIDResponse.cxx:1052
 AliTPCPIDResponse.cxx:1053
 AliTPCPIDResponse.cxx:1054
 AliTPCPIDResponse.cxx:1055
 AliTPCPIDResponse.cxx:1056
 AliTPCPIDResponse.cxx:1057
 AliTPCPIDResponse.cxx:1058
 AliTPCPIDResponse.cxx:1059
 AliTPCPIDResponse.cxx:1060
 AliTPCPIDResponse.cxx:1061
 AliTPCPIDResponse.cxx:1062
 AliTPCPIDResponse.cxx:1063
 AliTPCPIDResponse.cxx:1064
 AliTPCPIDResponse.cxx:1065
 AliTPCPIDResponse.cxx:1066
 AliTPCPIDResponse.cxx:1067
 AliTPCPIDResponse.cxx:1068
 AliTPCPIDResponse.cxx:1069
 AliTPCPIDResponse.cxx:1070
 AliTPCPIDResponse.cxx:1071
 AliTPCPIDResponse.cxx:1072
 AliTPCPIDResponse.cxx:1073
 AliTPCPIDResponse.cxx:1074
 AliTPCPIDResponse.cxx:1075
 AliTPCPIDResponse.cxx:1076
 AliTPCPIDResponse.cxx:1077
 AliTPCPIDResponse.cxx:1078
 AliTPCPIDResponse.cxx:1079
 AliTPCPIDResponse.cxx:1080
 AliTPCPIDResponse.cxx:1081
 AliTPCPIDResponse.cxx:1082
 AliTPCPIDResponse.cxx:1083
 AliTPCPIDResponse.cxx:1084
 AliTPCPIDResponse.cxx:1085
 AliTPCPIDResponse.cxx:1086
 AliTPCPIDResponse.cxx:1087
 AliTPCPIDResponse.cxx:1088
 AliTPCPIDResponse.cxx:1089
 AliTPCPIDResponse.cxx:1090
 AliTPCPIDResponse.cxx:1091
 AliTPCPIDResponse.cxx:1092
 AliTPCPIDResponse.cxx:1093
 AliTPCPIDResponse.cxx:1094
 AliTPCPIDResponse.cxx:1095
 AliTPCPIDResponse.cxx:1096
 AliTPCPIDResponse.cxx:1097
 AliTPCPIDResponse.cxx:1098
 AliTPCPIDResponse.cxx:1099
 AliTPCPIDResponse.cxx:1100
 AliTPCPIDResponse.cxx:1101
 AliTPCPIDResponse.cxx:1102
 AliTPCPIDResponse.cxx:1103
 AliTPCPIDResponse.cxx:1104
 AliTPCPIDResponse.cxx:1105
 AliTPCPIDResponse.cxx:1106
 AliTPCPIDResponse.cxx:1107
 AliTPCPIDResponse.cxx:1108
 AliTPCPIDResponse.cxx:1109
 AliTPCPIDResponse.cxx:1110
 AliTPCPIDResponse.cxx:1111
 AliTPCPIDResponse.cxx:1112
 AliTPCPIDResponse.cxx:1113
 AliTPCPIDResponse.cxx:1114
 AliTPCPIDResponse.cxx:1115
 AliTPCPIDResponse.cxx:1116
 AliTPCPIDResponse.cxx:1117
 AliTPCPIDResponse.cxx:1118
 AliTPCPIDResponse.cxx:1119
 AliTPCPIDResponse.cxx:1120
 AliTPCPIDResponse.cxx:1121
 AliTPCPIDResponse.cxx:1122
 AliTPCPIDResponse.cxx:1123
 AliTPCPIDResponse.cxx:1124
 AliTPCPIDResponse.cxx:1125
 AliTPCPIDResponse.cxx:1126
 AliTPCPIDResponse.cxx:1127
 AliTPCPIDResponse.cxx:1128
 AliTPCPIDResponse.cxx:1129
 AliTPCPIDResponse.cxx:1130
 AliTPCPIDResponse.cxx:1131
 AliTPCPIDResponse.cxx:1132
 AliTPCPIDResponse.cxx:1133
 AliTPCPIDResponse.cxx:1134
 AliTPCPIDResponse.cxx:1135
 AliTPCPIDResponse.cxx:1136
 AliTPCPIDResponse.cxx:1137
 AliTPCPIDResponse.cxx:1138
 AliTPCPIDResponse.cxx:1139
 AliTPCPIDResponse.cxx:1140
 AliTPCPIDResponse.cxx:1141
 AliTPCPIDResponse.cxx:1142
 AliTPCPIDResponse.cxx:1143
 AliTPCPIDResponse.cxx:1144
 AliTPCPIDResponse.cxx:1145
 AliTPCPIDResponse.cxx:1146
 AliTPCPIDResponse.cxx:1147
 AliTPCPIDResponse.cxx:1148
 AliTPCPIDResponse.cxx:1149
 AliTPCPIDResponse.cxx:1150
 AliTPCPIDResponse.cxx:1151
 AliTPCPIDResponse.cxx:1152
 AliTPCPIDResponse.cxx:1153
 AliTPCPIDResponse.cxx:1154
 AliTPCPIDResponse.cxx:1155
 AliTPCPIDResponse.cxx:1156
 AliTPCPIDResponse.cxx:1157
 AliTPCPIDResponse.cxx:1158
 AliTPCPIDResponse.cxx:1159
 AliTPCPIDResponse.cxx:1160
 AliTPCPIDResponse.cxx:1161
 AliTPCPIDResponse.cxx:1162
 AliTPCPIDResponse.cxx:1163
 AliTPCPIDResponse.cxx:1164
 AliTPCPIDResponse.cxx:1165
 AliTPCPIDResponse.cxx:1166
 AliTPCPIDResponse.cxx:1167
 AliTPCPIDResponse.cxx:1168
 AliTPCPIDResponse.cxx:1169
 AliTPCPIDResponse.cxx:1170
 AliTPCPIDResponse.cxx:1171
 AliTPCPIDResponse.cxx:1172
 AliTPCPIDResponse.cxx:1173
 AliTPCPIDResponse.cxx:1174
 AliTPCPIDResponse.cxx:1175
 AliTPCPIDResponse.cxx:1176
 AliTPCPIDResponse.cxx:1177
 AliTPCPIDResponse.cxx:1178
 AliTPCPIDResponse.cxx:1179
 AliTPCPIDResponse.cxx:1180
 AliTPCPIDResponse.cxx:1181
 AliTPCPIDResponse.cxx:1182
 AliTPCPIDResponse.cxx:1183
 AliTPCPIDResponse.cxx:1184
 AliTPCPIDResponse.cxx:1185
 AliTPCPIDResponse.cxx:1186
 AliTPCPIDResponse.cxx:1187
 AliTPCPIDResponse.cxx:1188
 AliTPCPIDResponse.cxx:1189
 AliTPCPIDResponse.cxx:1190
 AliTPCPIDResponse.cxx:1191
 AliTPCPIDResponse.cxx:1192
 AliTPCPIDResponse.cxx:1193
 AliTPCPIDResponse.cxx:1194
 AliTPCPIDResponse.cxx:1195
 AliTPCPIDResponse.cxx:1196
 AliTPCPIDResponse.cxx:1197
 AliTPCPIDResponse.cxx:1198
 AliTPCPIDResponse.cxx:1199
 AliTPCPIDResponse.cxx:1200
 AliTPCPIDResponse.cxx:1201
 AliTPCPIDResponse.cxx:1202
 AliTPCPIDResponse.cxx:1203
 AliTPCPIDResponse.cxx:1204
 AliTPCPIDResponse.cxx:1205
 AliTPCPIDResponse.cxx:1206
 AliTPCPIDResponse.cxx:1207
 AliTPCPIDResponse.cxx:1208
 AliTPCPIDResponse.cxx:1209
 AliTPCPIDResponse.cxx:1210
 AliTPCPIDResponse.cxx:1211
 AliTPCPIDResponse.cxx:1212
 AliTPCPIDResponse.cxx:1213
 AliTPCPIDResponse.cxx:1214
 AliTPCPIDResponse.cxx:1215
 AliTPCPIDResponse.cxx:1216
 AliTPCPIDResponse.cxx:1217
 AliTPCPIDResponse.cxx:1218
 AliTPCPIDResponse.cxx:1219
 AliTPCPIDResponse.cxx:1220
 AliTPCPIDResponse.cxx:1221
 AliTPCPIDResponse.cxx:1222
 AliTPCPIDResponse.cxx:1223
 AliTPCPIDResponse.cxx:1224
 AliTPCPIDResponse.cxx:1225
 AliTPCPIDResponse.cxx:1226
 AliTPCPIDResponse.cxx:1227
 AliTPCPIDResponse.cxx:1228
 AliTPCPIDResponse.cxx:1229
 AliTPCPIDResponse.cxx:1230
 AliTPCPIDResponse.cxx:1231
 AliTPCPIDResponse.cxx:1232
 AliTPCPIDResponse.cxx:1233
 AliTPCPIDResponse.cxx:1234
 AliTPCPIDResponse.cxx:1235
 AliTPCPIDResponse.cxx:1236
 AliTPCPIDResponse.cxx:1237
 AliTPCPIDResponse.cxx:1238
 AliTPCPIDResponse.cxx:1239
 AliTPCPIDResponse.cxx:1240
 AliTPCPIDResponse.cxx:1241
 AliTPCPIDResponse.cxx:1242
 AliTPCPIDResponse.cxx:1243
 AliTPCPIDResponse.cxx:1244
 AliTPCPIDResponse.cxx:1245
 AliTPCPIDResponse.cxx:1246
 AliTPCPIDResponse.cxx:1247
 AliTPCPIDResponse.cxx:1248
 AliTPCPIDResponse.cxx:1249
 AliTPCPIDResponse.cxx:1250
 AliTPCPIDResponse.cxx:1251
 AliTPCPIDResponse.cxx:1252
 AliTPCPIDResponse.cxx:1253
 AliTPCPIDResponse.cxx:1254
 AliTPCPIDResponse.cxx:1255
 AliTPCPIDResponse.cxx:1256
 AliTPCPIDResponse.cxx:1257
 AliTPCPIDResponse.cxx:1258
 AliTPCPIDResponse.cxx:1259
 AliTPCPIDResponse.cxx:1260
 AliTPCPIDResponse.cxx:1261
 AliTPCPIDResponse.cxx:1262
 AliTPCPIDResponse.cxx:1263
 AliTPCPIDResponse.cxx:1264
 AliTPCPIDResponse.cxx:1265
 AliTPCPIDResponse.cxx:1266
 AliTPCPIDResponse.cxx:1267
 AliTPCPIDResponse.cxx:1268
 AliTPCPIDResponse.cxx:1269
 AliTPCPIDResponse.cxx:1270
 AliTPCPIDResponse.cxx:1271
 AliTPCPIDResponse.cxx:1272
 AliTPCPIDResponse.cxx:1273
 AliTPCPIDResponse.cxx:1274
 AliTPCPIDResponse.cxx:1275
 AliTPCPIDResponse.cxx:1276
 AliTPCPIDResponse.cxx:1277
 AliTPCPIDResponse.cxx:1278
 AliTPCPIDResponse.cxx:1279
 AliTPCPIDResponse.cxx:1280
 AliTPCPIDResponse.cxx:1281
 AliTPCPIDResponse.cxx:1282
 AliTPCPIDResponse.cxx:1283
 AliTPCPIDResponse.cxx:1284
 AliTPCPIDResponse.cxx:1285
 AliTPCPIDResponse.cxx:1286
 AliTPCPIDResponse.cxx:1287
 AliTPCPIDResponse.cxx:1288
 AliTPCPIDResponse.cxx:1289
 AliTPCPIDResponse.cxx:1290
 AliTPCPIDResponse.cxx:1291
 AliTPCPIDResponse.cxx:1292
 AliTPCPIDResponse.cxx:1293
 AliTPCPIDResponse.cxx:1294
 AliTPCPIDResponse.cxx:1295
 AliTPCPIDResponse.cxx:1296
 AliTPCPIDResponse.cxx:1297
 AliTPCPIDResponse.cxx:1298
 AliTPCPIDResponse.cxx:1299
 AliTPCPIDResponse.cxx:1300
 AliTPCPIDResponse.cxx:1301
 AliTPCPIDResponse.cxx:1302
 AliTPCPIDResponse.cxx:1303
 AliTPCPIDResponse.cxx:1304
 AliTPCPIDResponse.cxx:1305
 AliTPCPIDResponse.cxx:1306
 AliTPCPIDResponse.cxx:1307
 AliTPCPIDResponse.cxx:1308
 AliTPCPIDResponse.cxx:1309
 AliTPCPIDResponse.cxx:1310
 AliTPCPIDResponse.cxx:1311
 AliTPCPIDResponse.cxx:1312
 AliTPCPIDResponse.cxx:1313
 AliTPCPIDResponse.cxx:1314
 AliTPCPIDResponse.cxx:1315
 AliTPCPIDResponse.cxx:1316
 AliTPCPIDResponse.cxx:1317
 AliTPCPIDResponse.cxx:1318
 AliTPCPIDResponse.cxx:1319
 AliTPCPIDResponse.cxx:1320
 AliTPCPIDResponse.cxx:1321
 AliTPCPIDResponse.cxx:1322
 AliTPCPIDResponse.cxx:1323
 AliTPCPIDResponse.cxx:1324
 AliTPCPIDResponse.cxx:1325
 AliTPCPIDResponse.cxx:1326
 AliTPCPIDResponse.cxx:1327
 AliTPCPIDResponse.cxx:1328
 AliTPCPIDResponse.cxx:1329
 AliTPCPIDResponse.cxx:1330
 AliTPCPIDResponse.cxx:1331
 AliTPCPIDResponse.cxx:1332
 AliTPCPIDResponse.cxx:1333
 AliTPCPIDResponse.cxx:1334
 AliTPCPIDResponse.cxx:1335
 AliTPCPIDResponse.cxx:1336
 AliTPCPIDResponse.cxx:1337
 AliTPCPIDResponse.cxx:1338
 AliTPCPIDResponse.cxx:1339
 AliTPCPIDResponse.cxx:1340
 AliTPCPIDResponse.cxx:1341
 AliTPCPIDResponse.cxx:1342
 AliTPCPIDResponse.cxx:1343
 AliTPCPIDResponse.cxx:1344
 AliTPCPIDResponse.cxx:1345
 AliTPCPIDResponse.cxx:1346
 AliTPCPIDResponse.cxx:1347
 AliTPCPIDResponse.cxx:1348
 AliTPCPIDResponse.cxx:1349
 AliTPCPIDResponse.cxx:1350
 AliTPCPIDResponse.cxx:1351
 AliTPCPIDResponse.cxx:1352
 AliTPCPIDResponse.cxx:1353
 AliTPCPIDResponse.cxx:1354
 AliTPCPIDResponse.cxx:1355
 AliTPCPIDResponse.cxx:1356
 AliTPCPIDResponse.cxx:1357
 AliTPCPIDResponse.cxx:1358
 AliTPCPIDResponse.cxx:1359
 AliTPCPIDResponse.cxx:1360
 AliTPCPIDResponse.cxx:1361
 AliTPCPIDResponse.cxx:1362
 AliTPCPIDResponse.cxx:1363
 AliTPCPIDResponse.cxx:1364
 AliTPCPIDResponse.cxx:1365
 AliTPCPIDResponse.cxx:1366
 AliTPCPIDResponse.cxx:1367
 AliTPCPIDResponse.cxx:1368
 AliTPCPIDResponse.cxx:1369
 AliTPCPIDResponse.cxx:1370
 AliTPCPIDResponse.cxx:1371
 AliTPCPIDResponse.cxx:1372
 AliTPCPIDResponse.cxx:1373
 AliTPCPIDResponse.cxx:1374
 AliTPCPIDResponse.cxx:1375
 AliTPCPIDResponse.cxx:1376
 AliTPCPIDResponse.cxx:1377
 AliTPCPIDResponse.cxx:1378
 AliTPCPIDResponse.cxx:1379
 AliTPCPIDResponse.cxx:1380
 AliTPCPIDResponse.cxx:1381
 AliTPCPIDResponse.cxx:1382
 AliTPCPIDResponse.cxx:1383
 AliTPCPIDResponse.cxx:1384
 AliTPCPIDResponse.cxx:1385
 AliTPCPIDResponse.cxx:1386
 AliTPCPIDResponse.cxx:1387
 AliTPCPIDResponse.cxx:1388
 AliTPCPIDResponse.cxx:1389
 AliTPCPIDResponse.cxx:1390
 AliTPCPIDResponse.cxx:1391
 AliTPCPIDResponse.cxx:1392
 AliTPCPIDResponse.cxx:1393
 AliTPCPIDResponse.cxx:1394
 AliTPCPIDResponse.cxx:1395
 AliTPCPIDResponse.cxx:1396
 AliTPCPIDResponse.cxx:1397
 AliTPCPIDResponse.cxx:1398
 AliTPCPIDResponse.cxx:1399
 AliTPCPIDResponse.cxx:1400
 AliTPCPIDResponse.cxx:1401
 AliTPCPIDResponse.cxx:1402
 AliTPCPIDResponse.cxx:1403
 AliTPCPIDResponse.cxx:1404
 AliTPCPIDResponse.cxx:1405
 AliTPCPIDResponse.cxx:1406
 AliTPCPIDResponse.cxx:1407
 AliTPCPIDResponse.cxx:1408
 AliTPCPIDResponse.cxx:1409
 AliTPCPIDResponse.cxx:1410
 AliTPCPIDResponse.cxx:1411
 AliTPCPIDResponse.cxx:1412
 AliTPCPIDResponse.cxx:1413
 AliTPCPIDResponse.cxx:1414
 AliTPCPIDResponse.cxx:1415
 AliTPCPIDResponse.cxx:1416
 AliTPCPIDResponse.cxx:1417
 AliTPCPIDResponse.cxx:1418
 AliTPCPIDResponse.cxx:1419
 AliTPCPIDResponse.cxx:1420
 AliTPCPIDResponse.cxx:1421
 AliTPCPIDResponse.cxx:1422
 AliTPCPIDResponse.cxx:1423
 AliTPCPIDResponse.cxx:1424
 AliTPCPIDResponse.cxx:1425
 AliTPCPIDResponse.cxx:1426
 AliTPCPIDResponse.cxx:1427
 AliTPCPIDResponse.cxx:1428
 AliTPCPIDResponse.cxx:1429
 AliTPCPIDResponse.cxx:1430
 AliTPCPIDResponse.cxx:1431
 AliTPCPIDResponse.cxx:1432
 AliTPCPIDResponse.cxx:1433
 AliTPCPIDResponse.cxx:1434
 AliTPCPIDResponse.cxx:1435
 AliTPCPIDResponse.cxx:1436
 AliTPCPIDResponse.cxx:1437
 AliTPCPIDResponse.cxx:1438
 AliTPCPIDResponse.cxx:1439
 AliTPCPIDResponse.cxx:1440
 AliTPCPIDResponse.cxx:1441
 AliTPCPIDResponse.cxx:1442
 AliTPCPIDResponse.cxx:1443
 AliTPCPIDResponse.cxx:1444
 AliTPCPIDResponse.cxx:1445
 AliTPCPIDResponse.cxx:1446
 AliTPCPIDResponse.cxx:1447
 AliTPCPIDResponse.cxx:1448
 AliTPCPIDResponse.cxx:1449
 AliTPCPIDResponse.cxx:1450
 AliTPCPIDResponse.cxx:1451
 AliTPCPIDResponse.cxx:1452
 AliTPCPIDResponse.cxx:1453
 AliTPCPIDResponse.cxx:1454
 AliTPCPIDResponse.cxx:1455
 AliTPCPIDResponse.cxx:1456
 AliTPCPIDResponse.cxx:1457
 AliTPCPIDResponse.cxx:1458
 AliTPCPIDResponse.cxx:1459
 AliTPCPIDResponse.cxx:1460
 AliTPCPIDResponse.cxx:1461
 AliTPCPIDResponse.cxx:1462
 AliTPCPIDResponse.cxx:1463
 AliTPCPIDResponse.cxx:1464
 AliTPCPIDResponse.cxx:1465
 AliTPCPIDResponse.cxx:1466
 AliTPCPIDResponse.cxx:1467
 AliTPCPIDResponse.cxx:1468
 AliTPCPIDResponse.cxx:1469
 AliTPCPIDResponse.cxx:1470
 AliTPCPIDResponse.cxx:1471
 AliTPCPIDResponse.cxx:1472
 AliTPCPIDResponse.cxx:1473
 AliTPCPIDResponse.cxx:1474
 AliTPCPIDResponse.cxx:1475
 AliTPCPIDResponse.cxx:1476
 AliTPCPIDResponse.cxx:1477
 AliTPCPIDResponse.cxx:1478
 AliTPCPIDResponse.cxx:1479
 AliTPCPIDResponse.cxx:1480
 AliTPCPIDResponse.cxx:1481
 AliTPCPIDResponse.cxx:1482
 AliTPCPIDResponse.cxx:1483
 AliTPCPIDResponse.cxx:1484
 AliTPCPIDResponse.cxx:1485
 AliTPCPIDResponse.cxx:1486
 AliTPCPIDResponse.cxx:1487
 AliTPCPIDResponse.cxx:1488
 AliTPCPIDResponse.cxx:1489
 AliTPCPIDResponse.cxx:1490
 AliTPCPIDResponse.cxx:1491
 AliTPCPIDResponse.cxx:1492
 AliTPCPIDResponse.cxx:1493
 AliTPCPIDResponse.cxx:1494
 AliTPCPIDResponse.cxx:1495
 AliTPCPIDResponse.cxx:1496
 AliTPCPIDResponse.cxx:1497
 AliTPCPIDResponse.cxx:1498
 AliTPCPIDResponse.cxx:1499
 AliTPCPIDResponse.cxx:1500
 AliTPCPIDResponse.cxx:1501
 AliTPCPIDResponse.cxx:1502
 AliTPCPIDResponse.cxx:1503
 AliTPCPIDResponse.cxx:1504
 AliTPCPIDResponse.cxx:1505
 AliTPCPIDResponse.cxx:1506
 AliTPCPIDResponse.cxx:1507
 AliTPCPIDResponse.cxx:1508
 AliTPCPIDResponse.cxx:1509
 AliTPCPIDResponse.cxx:1510
 AliTPCPIDResponse.cxx:1511
 AliTPCPIDResponse.cxx:1512
 AliTPCPIDResponse.cxx:1513
 AliTPCPIDResponse.cxx:1514
 AliTPCPIDResponse.cxx:1515
 AliTPCPIDResponse.cxx:1516
 AliTPCPIDResponse.cxx:1517
 AliTPCPIDResponse.cxx:1518
 AliTPCPIDResponse.cxx:1519
 AliTPCPIDResponse.cxx:1520
 AliTPCPIDResponse.cxx:1521
 AliTPCPIDResponse.cxx:1522
 AliTPCPIDResponse.cxx:1523
 AliTPCPIDResponse.cxx:1524
 AliTPCPIDResponse.cxx:1525
 AliTPCPIDResponse.cxx:1526
 AliTPCPIDResponse.cxx:1527
 AliTPCPIDResponse.cxx:1528
 AliTPCPIDResponse.cxx:1529
 AliTPCPIDResponse.cxx:1530
 AliTPCPIDResponse.cxx:1531
 AliTPCPIDResponse.cxx:1532
 AliTPCPIDResponse.cxx:1533
 AliTPCPIDResponse.cxx:1534
 AliTPCPIDResponse.cxx:1535
 AliTPCPIDResponse.cxx:1536
 AliTPCPIDResponse.cxx:1537
 AliTPCPIDResponse.cxx:1538
 AliTPCPIDResponse.cxx:1539
 AliTPCPIDResponse.cxx:1540
 AliTPCPIDResponse.cxx:1541
 AliTPCPIDResponse.cxx:1542
 AliTPCPIDResponse.cxx:1543
 AliTPCPIDResponse.cxx:1544
 AliTPCPIDResponse.cxx:1545
 AliTPCPIDResponse.cxx:1546
 AliTPCPIDResponse.cxx:1547
 AliTPCPIDResponse.cxx:1548
 AliTPCPIDResponse.cxx:1549
 AliTPCPIDResponse.cxx:1550
 AliTPCPIDResponse.cxx:1551
 AliTPCPIDResponse.cxx:1552
 AliTPCPIDResponse.cxx:1553
 AliTPCPIDResponse.cxx:1554
 AliTPCPIDResponse.cxx:1555
 AliTPCPIDResponse.cxx:1556
 AliTPCPIDResponse.cxx:1557
 AliTPCPIDResponse.cxx:1558
 AliTPCPIDResponse.cxx:1559
 AliTPCPIDResponse.cxx:1560
 AliTPCPIDResponse.cxx:1561
 AliTPCPIDResponse.cxx:1562
 AliTPCPIDResponse.cxx:1563
 AliTPCPIDResponse.cxx:1564
 AliTPCPIDResponse.cxx:1565
 AliTPCPIDResponse.cxx:1566
 AliTPCPIDResponse.cxx:1567
 AliTPCPIDResponse.cxx:1568
 AliTPCPIDResponse.cxx:1569
 AliTPCPIDResponse.cxx:1570
 AliTPCPIDResponse.cxx:1571
 AliTPCPIDResponse.cxx:1572
 AliTPCPIDResponse.cxx:1573
 AliTPCPIDResponse.cxx:1574
 AliTPCPIDResponse.cxx:1575
 AliTPCPIDResponse.cxx:1576
 AliTPCPIDResponse.cxx:1577
 AliTPCPIDResponse.cxx:1578
 AliTPCPIDResponse.cxx:1579
 AliTPCPIDResponse.cxx:1580
 AliTPCPIDResponse.cxx:1581
 AliTPCPIDResponse.cxx:1582
 AliTPCPIDResponse.cxx:1583
 AliTPCPIDResponse.cxx:1584
 AliTPCPIDResponse.cxx:1585
 AliTPCPIDResponse.cxx:1586
 AliTPCPIDResponse.cxx:1587
 AliTPCPIDResponse.cxx:1588
 AliTPCPIDResponse.cxx:1589