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


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// TRD tender: reapply pid on the fly                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <TChain.h>
#include <TDirectory.h>
#include <TFile.h>
#include <TList.h>
#include <TObjString.h>
#include <TTree.h>
#include <TString.h>
#include <TVectorD.h>

#include <AliCDBEntry.h>
#include <AliCDBId.h>
#include <AliCDBManager.h>
#include <AliOADBContainer.h>
#include <AliTRDCalDet.h>
#include "AliTRDonlineTrackMatching.h"

#include <AliLog.h>
#include <TTree.h>
#include <TChain.h>
#include <AliGeomManager.h>
#include <AliPID.h>
#include <AliVEvent.h>
#include <AliESDEvent.h>
#include <AliESDpid.h>
#include <AliESDtrack.h>
#include <AliESDInputHandler.h>
#include <AliAnalysisManager.h>
#include <AliTrackerBase.h>
#include <AliTRDPIDReference.h>
#include <AliTRDPIDResponse.h>
#include <AliTRDCalChamberStatus.h>
#include <AliTender.h>

#include "AliTRDTenderSupply.h"

ClassImp(AliTRDTenderSupply)

//_____________________________________________________
AliTRDTenderSupply::AliTRDTenderSupply() :
  AliTenderSupply(),
  fESD(NULL),
  fESDpid(NULL),
  fTrdOnlineTrackMatcher(NULL),
  fChamberGainOld(NULL),
  fChamberGainNew(NULL),
  fChamberVdriftOld(NULL),
  fChamberVdriftNew(NULL),
  fRunByRunCorrection(NULL),
  fPIDmethod(k1DLQpid),
  fNormalizationFactor(1.),
  fPthreshold(0.8),
  fNBadChambers(0),
  fGeoFile(NULL),
  fGainCorrection(kTRUE),
//  fLoadReferences(kFALSE),
//  fLoadReferencesFromCDB(kFALSE),
  fLoadDeadChambers(kFALSE),
  fHasReferences(kFALSE),
  fHasNewCalibration(kTRUE),
  fDebugMode(kFALSE),
  fRedoTrdMatching(kTRUE),
  fNameRunByRunCorrection(),
  fNormalizationFactorArray(NULL)
{
  //
  // default ctor
  //
  memset(fBadChamberID, 0, sizeof(Int_t) * kNChambers);
  memset(fSlicesForPID, 0, sizeof(UInt_t) * 2);
}

//_____________________________________________________
AliTRDTenderSupply::AliTRDTenderSupply(const char *name, const AliTender *tender) :
  AliTenderSupply(name,tender),
  fESD(NULL),
  fESDpid(NULL),
  fTrdOnlineTrackMatcher(NULL),
  fChamberGainOld(NULL),
  fChamberGainNew(NULL),
  fChamberVdriftOld(NULL),
  fChamberVdriftNew(NULL),
  fRunByRunCorrection(NULL),
  fPIDmethod(k1DLQpid),
  fNormalizationFactor(1.),
  fPthreshold(0.8),
  fNBadChambers(0),
  fGeoFile(NULL),
  fGainCorrection(kTRUE),
//  fLoadReferences(kFALSE),
//  fLoadReferencesFromCDB(kFALSE),
  fLoadDeadChambers(kFALSE),
  fHasReferences(kFALSE),
  fHasNewCalibration(kTRUE),
  fDebugMode(kFALSE),
  fRedoTrdMatching(kTRUE),
  fNameRunByRunCorrection(),
  fNormalizationFactorArray(NULL)
{
  //
  // named ctor
  //
  memset(fSlicesForPID, 0, sizeof(UInt_t) * 2);
  memset(fBadChamberID, 0, sizeof(Int_t) * kNChambers);
}

//_____________________________________________________
AliTRDTenderSupply::~AliTRDTenderSupply()
{
  //
  // dtor
  //
    if(fNormalizationFactorArray) delete fNormalizationFactorArray;
    delete fTrdOnlineTrackMatcher;
}

//_____________________________________________________
void AliTRDTenderSupply::Init()
{
  //
  // Initialise TRD tender
  //

  AliAnalysisManager *mgr=AliAnalysisManager::GetAnalysisManager();
  
  // 1DLQ PID implemented in the AliESD object
  fESDpid=fTender->GetESDhandler()->GetESDpid();
  if (!fESDpid) {
    fESDpid=new AliESDpid;
    fTender->GetESDhandler()->SetESDpid(fESDpid);
  }
  // Load References
  //if(fLoadReferences && !fLoadReferencesFromCDB) LoadReferences();
  //fESDpid->GetTRDResponse().SetGainNormalisationFactor(fNormalizationFactor);
  //fESDpid->SetTRDslicesForPID(fSlicesForPID[0], fSlicesForPID[1]);

  if(fNameRunByRunCorrection.Length()) LoadRunByRunCorrection(fNameRunByRunCorrection.Data());
  fTrdOnlineTrackMatcher=new AliTRDonlineTrackMatching();
  // Set Normalisation Factors
  if(mgr->GetMCtruthEventHandler()){
    // Assume MC
    //fESDpid->GetTRDResponse().SetGainNormalisationFactor(1.);
    SwitchOffGainCorrection();
  }
  else{
    // Assume Data
    //if(fPIDmethod == kNNpid) fPidRecal->SetGainScaleFactor(1.14);
    //fESDpid->GetTRDResponse().SetGainNormalisationFactor(1.14);
    SwitchOnGainCorrection();
  }
}

//_____________________________________________________
void AliTRDTenderSupply::ProcessEvent()
{
  //
  // Reapply pid information
  //
  if (fTender->RunChanged()){
    AliDebug(0, Form("AliTPCTenderSupply::ProcessEvent - Run Changed (%d)\n",fTender->GetRun()));
    if (fGainCorrection) SetChamberGain();
    //if(fLoadReferences && !fHasReferences) LoadReferences();
    if(fLoadDeadChambers) LoadDeadChambersFromCDB();
    // Load Geometry
    if(AliGeomManager::GetGeometry()){
      AliInfo("Geometry already loaded by other tenders");
    } else {
      if(fGeoFile) AliInfo(Form("Load geometry from file %s\n", fGeoFile));
      else AliInfo("Load Geometry from OCDB\n");
      AliGeomManager::LoadGeometry(fGeoFile);
    }
  }


  fESD = fTender->GetEvent();
  if (!fESD) return;
  if(fNormalizationFactorArray) fNormalizationFactor = GetNormalizationFactor(fESD->GetRunNumber());
  Int_t ntracks=fESD->GetNumberOfTracks();



  if (fRedoTrdMatching) {
      if (!fTrdOnlineTrackMatcher->ProcessEvent(fESD)) {
	  AliError("TRD online track matching failed!");
      } 
  }



  //
  // recalculate PID probabilities
  //
  Int_t detectors[kNPlanes];
  for(Int_t itrack = 0; itrack < ntracks; itrack++){
    for(Int_t idet = 0; idet < 5; idet++) detectors[idet] = -1;
    AliESDtrack *track=fESD->GetTrack(itrack);
    // Recalculate likelihoods
    if(!(track->GetStatus() & AliESDtrack::kTRDout)) continue;
    AliDebug(2, Form("TRD track found, gain correction: %s, Number of bad chambers: %d\n", fGainCorrection ? "Yes" : "No", fNBadChambers));
    if(GetTRDchamberID(track, detectors)){
      if(fGainCorrection && fHasNewCalibration) ApplyGainCorrection(track, detectors);
      if(fNBadChambers) MaskChambers(track, detectors);
    }
    if(fRunByRunCorrection) ApplyRunByRunCorrection(track);
    if(fNormalizationFactor != 1.){
      //printf("Gain Factor: %f\n", fNormalizationFactor);
      // Renormalize charge
      Double_t qslice = -1;
      for(Int_t ily = 0; ily < 6; ily++){
        for(Int_t is = 0; is < track->GetNumberOfTRDslices(); is++){
          qslice = track->GetTRDslice(ily, is);
          //printf("Doing layer %d slice %d, value %f\n", ily, is, qslice);
          if(qslice >0){
            qslice *= fNormalizationFactor;
            //printf("qslice new: %f\n", qslice);
            track->SetTRDslice(qslice, ily, is);
          }
        }
      }
    }
    switch(fPIDmethod){
      case kNNpid:
        break;
      case k1DLQpid:
        fESDpid->MakeTRDPID(fESD->GetTrack(itrack));
        break;
      default:
        AliError("PID Method not implemented (yet)");
    }
  }
}

//_____________________________________________________
void AliTRDTenderSupply::LoadDeadChambersFromCDB(){
  //
  // Load Dead Chambers from the OCDB
  //
  AliDebug(1, "Loading Dead Chambers from the OCDB");
  AliCDBEntry *en = fTender->GetCDBManager()->Get("TRD/Calib/ChamberStatus",fTender->GetRun());
  if(!en){
   AliError("Dead Chambers not in OCDB");
   return;
  }
  en->GetId().Print();

  AliTRDCalChamberStatus* chamberStatus = 0;
  if(en){
    chamberStatus = (AliTRDCalChamberStatus*)en->GetObject();
    if(!chamberStatus) AliError("List with the dead chambers not found");
    for(Int_t ichamber = 0; ichamber < 540; ichamber++) {
      if(!chamberStatus->IsGood(ichamber)){
        //printf("Chamber not installed %d\n",ichamber);
        AddBadChamber(ichamber);
      }
    }
  }
}

/*
//_____________________________________________________
void AliTRDTenderSupply::LoadReferences(){
  //
  // Load Reference from the OCDB/OADB into the PID Response
  //
  if(fLoadReferencesFromCDB){
    AliDebug(1, "Loading Reference Distributions from the OCDB");
    AliCDBEntry *en = fTender->GetCDBManager()->Get("TRD/Calib/PIDLQ1D");
    if(!en){
      AliError("References for 1D Likelihood Method not in OCDB");
      return;
    }
    en->GetId().Print();
    TObjArray *arr = dynamic_cast<TObjArray *>(en->GetObject());
    if(!arr) AliError("List with the references not found");
  
    // Get new references
    TIter refs(arr);
    TObject *o = NULL;
    AliTRDPIDReference *ref = NULL;
    while((o = refs())){
      if(!TString(o->IsA()->GetName()).CompareTo("AliTRDPIDReference")){
        ref = dynamic_cast<AliTRDPIDReference *>(o);
        break;
      }
    }
    if(ref){
      fESDpid->GetTRDResponse().Load(ref);
      fHasReferences = kTRUE;
      AliDebug(1, "Reference distributions loaded into the PID Response");
    } else {
      AliError("References not found");
    }
  } else {
    // Backward compatibility mode
    AliInfo("Loading Reference Distributions from ROOT file");
    fESDpid->GetTRDResponse().Load("$TRAIN_ROOT/util/tender/LQ1dRef_v3.root");
    fHasReferences = kTRUE;
  }
}
*/

//_____________________________________________________
void AliTRDTenderSupply::SetChamberGain(){
  //
  // Load Chamber Gain factors into the Tender supply
  //
  
  //find previous entry from the UserInfo
  TTree *tree=((TChain*)fTender->GetInputData(0))->GetTree();
  if (!tree) {
    fHasNewCalibration = kFALSE;
    AliError("Tree not found in ESDhandler");
    return;
  }
 	 
  TList *userInfo=(TList*)tree->GetUserInfo();
  if (!userInfo) {
    fHasNewCalibration = kFALSE;
    AliError("No UserInfo found in tree");
    return;
  }

  TList *cdbList=(TList*)userInfo->FindObject("cdbList");
  if (!cdbList) {
    fHasNewCalibration = kFALSE;
    AliError("No cdbList found in UserInfo");
    if (AliLog::GetGlobalLogLevel()>=AliLog::kError) userInfo->Print();
    return;
  }
  fHasNewCalibration = kTRUE;
 	
  TIter nextCDB(cdbList);
  TObjString *os=0x0;
  while ( (os=(TObjString*)nextCDB()) ){
    if(os->GetString().Contains("TRD/Calib/ChamberGainFactor")){
      // Get Old gain calibration
      AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
 	   
      AliCDBEntry *entry=fTender->GetCDBManager()->Get(id->GetPath(), id->GetFirstRun(), id->GetVersion());
      if (!entry) {
        AliError("No previous gain calibration entry found");
        return;
      }

      fChamberGainOld = dynamic_cast<AliTRDCalDet *>(entry->GetObject());
 	   
      AliDebug(1, Form("Used old Gain entry: %s\n",entry->GetId().ToString().Data()));
    } else if(os->GetString().Contains("TRD/Calib/ChamberVdrift")){
      // Get Old drift velocity calibration
      AliCDBId *id=AliCDBId::MakeFromString(os->GetString());
 	   
      AliCDBEntry *entry=fTender->GetCDBManager()->Get(id->GetPath(), id->GetFirstRun(), id->GetVersion());
      if (!entry) {
        AliError("No previous drift velocity calibration entry found");
        return;
      }

      fChamberVdriftOld = dynamic_cast<AliTRDCalDet *>(entry->GetObject());
 	   
      AliDebug(1, Form("Used old Drift velocity entry: %s\n",entry->GetId().ToString().Data()));
    
    }
  }

  // Get Latest Gain Calib Object
  AliCDBEntry *entryNew=fTender->GetCDBManager()->Get("TRD/Calib/ChamberGainFactor",fTender->GetRun());
  if (entryNew) {
    AliDebug(1, Form("Used new Gain entry: %s\n",entryNew->GetId().ToString().Data()));
    fChamberGainNew = dynamic_cast<AliTRDCalDet *>(entryNew->GetObject());
  } else
    AliError("No new gain calibration entry found");
  
  // Also get the latest Drift Velocity calibration object
  entryNew=fTender->GetCDBManager()->Get("TRD/Calib/ChamberVdrift",fTender->GetRun());
  if (entryNew) {
    AliDebug(1, Form("Used new Drift velocity entry: %s\n",entryNew->GetId().ToString().Data()));
    fChamberVdriftNew = dynamic_cast<AliTRDCalDet *>(entryNew->GetObject());
  } else
    AliError("No new drift velocity calibration entry found");

  if(!fChamberGainNew || !fChamberVdriftNew){
    AliError("No recent calibration found");
    fHasNewCalibration = kFALSE;
  }
}

//_____________________________________________________
void AliTRDTenderSupply::LoadRunByRunCorrection(const char *filename){
  //
  // Define run by run gain correction for the charge
  // 

  TDirectory *bkp = gDirectory;
  TFile *in = TFile::Open(filename);
  bkp->cd();
  fRunByRunCorrection = dynamic_cast<AliOADBContainer *>(in->Get("TRDchargeCorrection"));
  delete in;
  if(fRunByRunCorrection )
    AliDebug(2, Form("OADB Container has %d runs\n", fRunByRunCorrection->GetNumberOfEntries()));
  /* Temporarily out due to a bug in AliOADBContainer
  fRunByRunCorrection = new AliOADBContainer("TRDchargeCorrection");
  Int_t status = fRunByRunCorrection->InitFromFile(filename, "TRDchargeCorrection");
  if(!status) AliDebug(1, Form("Run-dependend gain correction factors loaded from OADB file %s", filename));
  else{
    AliDebug(1, "Failed Loading Run-dependend gain correction factors");
    delete fRunByRunCorrection;
    fRunByRunCorrection = NULL;
  }
  */
}

//_____________________________________________________
Bool_t AliTRDTenderSupply::IsBadChamber(Int_t chamberID){
  //
  // Check if the chamber id is in the list of bad chambers
  //
  Bool_t isBad = kFALSE;
  for(UInt_t icam = 0; icam < fNBadChambers; icam++)
    if(fBadChamberID[icam] == chamberID){
	    isBad = kTRUE;
	    //printf("cross checking: %i \n",chamberID);
      break;
    }
  return isBad;
}

//_____________________________________________________
void AliTRDTenderSupply::ApplyGainCorrection(AliESDtrack * track, const Int_t * const chamberID){
  //
  // Apply new gain factors to the track
  //
  if(!fChamberGainNew || !fChamberGainOld){
    AliError("Cannot apply gain correction.");
    return;
  }
 
  if(!(track->GetStatus() & AliESDtrack::kTRDout)) return;
  Bool_t applyCorrectionVdrift = kFALSE;
  if(fChamberVdriftOld && fChamberVdriftNew) applyCorrectionVdrift = kTRUE;

  for(Int_t iplane = 0; iplane < kNPlanes; iplane++){
    if(chamberID[iplane] < 0) continue;
    if(IsBadChamber(chamberID[iplane])) continue; // Don't apply gain correction for chambers which are in the list of bad chambers

    // Take old and new gain factor and make ratio
    Double_t facOld = fChamberGainOld->GetValue(chamberID[iplane]);
    Double_t facNew = fChamberGainNew->GetValue(chamberID[iplane]); 
    Double_t correction = facNew/facOld;
    if(applyCorrectionVdrift){
      // apply also correction for drift velocity calibration
      Double_t vDriftOld = fChamberVdriftOld->GetValue(chamberID[iplane]);
      Double_t vDriftNew = fChamberVdriftNew->GetValue(chamberID[iplane]);
      correction *= vDriftNew/vDriftOld;
    }
    AliDebug(2, Form("Applying correction factor %f\n", correction));
    for(Int_t islice = 0; islice < track->GetNumberOfTRDslices(); islice++){
      Double_t qslice = track->GetTRDslice(iplane, islice);
      if(qslice <= 0.) continue; 
      track->SetTRDslice(qslice / correction, iplane, islice);
    }
  }
}

//_____________________________________________________
void AliTRDTenderSupply::ApplyRunByRunCorrection(AliESDtrack *const track) {
  // 
  // Equalize charge distribution by applying run-by-run correction (multiplicative)
  //

  TVectorD *corrfactor = dynamic_cast<TVectorD *>(fRunByRunCorrection->GetObject(fTender->GetRun()));
  if(!corrfactor){ 
    // No correction available - simply return
    AliDebug(2, "Couldn't derive gain correction factor from OADB");
    return;
  }
  else AliDebug(2, Form("Gain factor from OADB %f", (*corrfactor)[0]));
  Double_t slice = 0;
  for(Int_t ily = 0; ily < kNPlanes; ily++){
    for(Int_t islice = 0; islice < track->GetNumberOfTRDslices(); islice++){
      slice = track->GetTRDslice(ily, islice);
      if(slice < 0.001) continue;   // do not modify slices which are 0 or negative
      slice *= (*corrfactor)[0];
      track->SetTRDslice(slice, ily, islice);
    }
  }
}

//_____________________________________________________
void AliTRDTenderSupply::SetNormalizationFactor(Double_t norm, Int_t runMin, Int_t runMax) {
  //
  // Set the normalisation factor for a given run range
  //
  if(!fNormalizationFactorArray)
    fNormalizationFactorArray = new TObjArray;
  TVectorD *entry = new TVectorD(3);
  TVectorD &myentry = *entry;
  myentry(0) = runMin;
  myentry(1) = runMax;
  myentry(2) = norm;
  fNormalizationFactorArray->Add(entry);
}

//_____________________________________________________
Double_t AliTRDTenderSupply::GetNormalizationFactor(Int_t runnumber){
  // 
  // Load the normalization factor
  //
  Double_t norm = 1.;
  if(fNormalizationFactorArray){
    TVectorD *entry;
    Int_t runMin, runMax;
    TIter entries(fNormalizationFactorArray);
    while((entry = dynamic_cast<TVectorD *>(entries()))){
      TVectorD &myentry = *entry;
      runMin = TMath::Nint(myentry(0));
      runMax = TMath::Nint(myentry(1));
      if(runnumber >= runMin && runnumber <= runMax) norm = myentry(2);
    }
  }
  AliDebug(1, Form("Gain normalization factor: %f\n", norm));
  return norm;
}

//_____________________________________________________
void AliTRDTenderSupply::MaskChambers(AliESDtrack *const track, const Int_t * const chamberID){
  //
  // Mask out chambers which are in the list of bad chambers
  // Set chamber signal to 0 and reduce the number of tracklets used for PID
  //
  AliDebug(2, "Masking bad chambers for TRD track");
  Int_t nTrackletsPID = 0, nslice = 0, nTracklets = track->GetTRDntracklets();
  Bool_t badChamber = kFALSE;
  //Int_t nbad = 0 ;      // Number of bad chambers which contain also a signal
  //Int_t nsliceBad = 0;  // Number of slices in tracklet in a bad chamber
  for(Int_t iplane = 0; iplane < kNPlanes; iplane++){
    badChamber = kFALSE;
    nslice = 0; //nsliceBad = 0;
    if(IsBadChamber(chamberID[iplane])) badChamber = kTRUE;
    for(Int_t islice = 0; islice < track->GetNumberOfTRDslices(); islice++){
      if(badChamber){
        //if(track->GetTRDslice(iplane, islice)) nsliceBad++;
        track->SetTRDslice(-1, iplane, islice);
      } else if(track->GetTRDslice(iplane, islice) > 0.001) nslice++;
    }
    //if(nsliceBad) nbad++;
    if(nslice > 0) nTrackletsPID++;
  }
  //if(nbad) track->SetTRDncls(track->GetTRDncls() - 20 * nbad);      // subtract mean number of clusters per tracklet for bad tracklets 
  // Use nTrackletsPID to indicate the number of tracklets from good
  // chambers so they are used for the PID
  track->SetTRDntracklets(nTrackletsPID | (nTracklets << 3));
}

//_____________________________________________________
Bool_t AliTRDTenderSupply::GetTRDchamberID(AliESDtrack * const track, Int_t *detectors) {
  //
  // Calculate TRD chamber ID
  //
  Double_t p = track->GetOuterParam() ? track->GetOuterParam()->P() : track->P();
  if(p < fPthreshold) return kFALSE; // Apply low momentum cutoff

  Double_t xLayer[kNPlanes] = {300.2, 312.8, 325.4, 338., 350.6, 363.2};
  Double_t etamin[kNStacks] = {0.536, 0.157, -0.145, -0.527,-0.851};
  Double_t etamax[kNStacks] = {0.851, 0.527, 0.145, -0.157,-0.536};
  //Double_t zboundary[kNPlanes] = {302., 317., 328., 343., 350., 350.};
  for(Int_t ily = 0; ily < kNPlanes; ily++) detectors[ily] = -1;

  const AliExternalTrackParam *trueparam = NULL;
  if(track->GetOuterParam()) trueparam = track->GetOuterParam();
  else if(track->GetTPCInnerParam()) trueparam = track->GetTPCInnerParam();
  else if(track->GetInnerParam()) trueparam = track->GetInnerParam();
  if(!trueparam){
    AliDebug(2, "No Track Params");
    return kFALSE;
  }

  AliExternalTrackParam workparam(*trueparam); // Do calculation on working Copy
  Double_t pos[3];
  Int_t nDet = 0;
  for(Int_t ily = 0; ily < kNPlanes; ily++){
    //if(TMath::Abs(workparam.GetZ()) > zboundary[ily]) break;
    //if(!AliTrackerBase::PropagateTrackToBxByBz(&workparam, xLayer[ily], 0.139, 100)){   // Assuming the pion mass
    if(!workparam.PropagateTo(xLayer[ily], fESD->GetMagneticField())) {
      AliDebug(2, "Propagation failed");
      break;
    }
    workparam.GetXYZ(pos);
    Double_t trackAlpha = TMath::ATan2(pos[1], pos[0]);
    if(trackAlpha < 0) trackAlpha = 2 * TMath::Pi() + trackAlpha;
    Double_t secAlpha = 2 * TMath::Pi() / 18.;
   
    Int_t sector = static_cast<Int_t>(trackAlpha/secAlpha);
/*
    if(fDebugMode){
      // Compare to simple propagation without magnetic field
      AliExternalTrackParam workparam1(*trueparam); // Do calculation on working Copy
      Double_t pos1[3];
      //if(!workparam1.PropagateTo(xLayer[ily], fESD->GetMagneticField())) {
      if(!AliTrackerBase::PropagateTrackToBxByBz(&workparam1, xLayer[ily], 0.139, 100)){   // Assuming the pion mass
        AliDebug(2, "Propagation failed");
        break;
      }
      workparam1.GetXYZ(pos1);
      Double_t trackAlpha1 = TMath::ATan2(pos1[1], pos1[0]);
      if(trackAlpha1 < 0) trackAlpha1 = 2 * TMath::Pi() + trackAlpha1;
   
      Int_t sector1 = static_cast<Int_t>(trackAlpha1/secAlpha);
      AliDebug(2, Form("Alpha: Old %f, New %f, diff %f", trackAlpha, trackAlpha1, trackAlpha-trackAlpha1));
      AliDebug(2, Form("Sector: Old %d, New %d", sector, sector1));
    }
*/
    Double_t etaTrack = track->Eta();
    Int_t stack = -1;
    for(Int_t istack = 0; istack < 5; istack++){
      if(etaTrack >= etamin[istack] && etaTrack <= etamax[istack]){
        stack = istack;
        break;
      }
    }
    if(stack < 0) {
      AliDebug(2, "Dead Area");
      continue;
    }

    detectors[ily] = sector * kNStacks * kNPlanes + stack * kNPlanes + ily;
    nDet++;
  }
  return nDet ? kTRUE : kFALSE;
}

 AliTRDTenderSupply.cxx:1
 AliTRDTenderSupply.cxx:2
 AliTRDTenderSupply.cxx:3
 AliTRDTenderSupply.cxx:4
 AliTRDTenderSupply.cxx:5
 AliTRDTenderSupply.cxx:6
 AliTRDTenderSupply.cxx:7
 AliTRDTenderSupply.cxx:8
 AliTRDTenderSupply.cxx:9
 AliTRDTenderSupply.cxx:10
 AliTRDTenderSupply.cxx:11
 AliTRDTenderSupply.cxx:12
 AliTRDTenderSupply.cxx:13
 AliTRDTenderSupply.cxx:14
 AliTRDTenderSupply.cxx:15
 AliTRDTenderSupply.cxx:16
 AliTRDTenderSupply.cxx:17
 AliTRDTenderSupply.cxx:18
 AliTRDTenderSupply.cxx:19
 AliTRDTenderSupply.cxx:20
 AliTRDTenderSupply.cxx:21
 AliTRDTenderSupply.cxx:22
 AliTRDTenderSupply.cxx:23
 AliTRDTenderSupply.cxx:24
 AliTRDTenderSupply.cxx:25
 AliTRDTenderSupply.cxx:26
 AliTRDTenderSupply.cxx:27
 AliTRDTenderSupply.cxx:28
 AliTRDTenderSupply.cxx:29
 AliTRDTenderSupply.cxx:30
 AliTRDTenderSupply.cxx:31
 AliTRDTenderSupply.cxx:32
 AliTRDTenderSupply.cxx:33
 AliTRDTenderSupply.cxx:34
 AliTRDTenderSupply.cxx:35
 AliTRDTenderSupply.cxx:36
 AliTRDTenderSupply.cxx:37
 AliTRDTenderSupply.cxx:38
 AliTRDTenderSupply.cxx:39
 AliTRDTenderSupply.cxx:40
 AliTRDTenderSupply.cxx:41
 AliTRDTenderSupply.cxx:42
 AliTRDTenderSupply.cxx:43
 AliTRDTenderSupply.cxx:44
 AliTRDTenderSupply.cxx:45
 AliTRDTenderSupply.cxx:46
 AliTRDTenderSupply.cxx:47
 AliTRDTenderSupply.cxx:48
 AliTRDTenderSupply.cxx:49
 AliTRDTenderSupply.cxx:50
 AliTRDTenderSupply.cxx:51
 AliTRDTenderSupply.cxx:52
 AliTRDTenderSupply.cxx:53
 AliTRDTenderSupply.cxx:54
 AliTRDTenderSupply.cxx:55
 AliTRDTenderSupply.cxx:56
 AliTRDTenderSupply.cxx:57
 AliTRDTenderSupply.cxx:58
 AliTRDTenderSupply.cxx:59
 AliTRDTenderSupply.cxx:60
 AliTRDTenderSupply.cxx:61
 AliTRDTenderSupply.cxx:62
 AliTRDTenderSupply.cxx:63
 AliTRDTenderSupply.cxx:64
 AliTRDTenderSupply.cxx:65
 AliTRDTenderSupply.cxx:66
 AliTRDTenderSupply.cxx:67
 AliTRDTenderSupply.cxx:68
 AliTRDTenderSupply.cxx:69
 AliTRDTenderSupply.cxx:70
 AliTRDTenderSupply.cxx:71
 AliTRDTenderSupply.cxx:72
 AliTRDTenderSupply.cxx:73
 AliTRDTenderSupply.cxx:74
 AliTRDTenderSupply.cxx:75
 AliTRDTenderSupply.cxx:76
 AliTRDTenderSupply.cxx:77
 AliTRDTenderSupply.cxx:78
 AliTRDTenderSupply.cxx:79
 AliTRDTenderSupply.cxx:80
 AliTRDTenderSupply.cxx:81
 AliTRDTenderSupply.cxx:82
 AliTRDTenderSupply.cxx:83
 AliTRDTenderSupply.cxx:84
 AliTRDTenderSupply.cxx:85
 AliTRDTenderSupply.cxx:86
 AliTRDTenderSupply.cxx:87
 AliTRDTenderSupply.cxx:88
 AliTRDTenderSupply.cxx:89
 AliTRDTenderSupply.cxx:90
 AliTRDTenderSupply.cxx:91
 AliTRDTenderSupply.cxx:92
 AliTRDTenderSupply.cxx:93
 AliTRDTenderSupply.cxx:94
 AliTRDTenderSupply.cxx:95
 AliTRDTenderSupply.cxx:96
 AliTRDTenderSupply.cxx:97
 AliTRDTenderSupply.cxx:98
 AliTRDTenderSupply.cxx:99
 AliTRDTenderSupply.cxx:100
 AliTRDTenderSupply.cxx:101
 AliTRDTenderSupply.cxx:102
 AliTRDTenderSupply.cxx:103
 AliTRDTenderSupply.cxx:104
 AliTRDTenderSupply.cxx:105
 AliTRDTenderSupply.cxx:106
 AliTRDTenderSupply.cxx:107
 AliTRDTenderSupply.cxx:108
 AliTRDTenderSupply.cxx:109
 AliTRDTenderSupply.cxx:110
 AliTRDTenderSupply.cxx:111
 AliTRDTenderSupply.cxx:112
 AliTRDTenderSupply.cxx:113
 AliTRDTenderSupply.cxx:114
 AliTRDTenderSupply.cxx:115
 AliTRDTenderSupply.cxx:116
 AliTRDTenderSupply.cxx:117
 AliTRDTenderSupply.cxx:118
 AliTRDTenderSupply.cxx:119
 AliTRDTenderSupply.cxx:120
 AliTRDTenderSupply.cxx:121
 AliTRDTenderSupply.cxx:122
 AliTRDTenderSupply.cxx:123
 AliTRDTenderSupply.cxx:124
 AliTRDTenderSupply.cxx:125
 AliTRDTenderSupply.cxx:126
 AliTRDTenderSupply.cxx:127
 AliTRDTenderSupply.cxx:128
 AliTRDTenderSupply.cxx:129
 AliTRDTenderSupply.cxx:130
 AliTRDTenderSupply.cxx:131
 AliTRDTenderSupply.cxx:132
 AliTRDTenderSupply.cxx:133
 AliTRDTenderSupply.cxx:134
 AliTRDTenderSupply.cxx:135
 AliTRDTenderSupply.cxx:136
 AliTRDTenderSupply.cxx:137
 AliTRDTenderSupply.cxx:138
 AliTRDTenderSupply.cxx:139
 AliTRDTenderSupply.cxx:140
 AliTRDTenderSupply.cxx:141
 AliTRDTenderSupply.cxx:142
 AliTRDTenderSupply.cxx:143
 AliTRDTenderSupply.cxx:144
 AliTRDTenderSupply.cxx:145
 AliTRDTenderSupply.cxx:146
 AliTRDTenderSupply.cxx:147
 AliTRDTenderSupply.cxx:148
 AliTRDTenderSupply.cxx:149
 AliTRDTenderSupply.cxx:150
 AliTRDTenderSupply.cxx:151
 AliTRDTenderSupply.cxx:152
 AliTRDTenderSupply.cxx:153
 AliTRDTenderSupply.cxx:154
 AliTRDTenderSupply.cxx:155
 AliTRDTenderSupply.cxx:156
 AliTRDTenderSupply.cxx:157
 AliTRDTenderSupply.cxx:158
 AliTRDTenderSupply.cxx:159
 AliTRDTenderSupply.cxx:160
 AliTRDTenderSupply.cxx:161
 AliTRDTenderSupply.cxx:162
 AliTRDTenderSupply.cxx:163
 AliTRDTenderSupply.cxx:164
 AliTRDTenderSupply.cxx:165
 AliTRDTenderSupply.cxx:166
 AliTRDTenderSupply.cxx:167
 AliTRDTenderSupply.cxx:168
 AliTRDTenderSupply.cxx:169
 AliTRDTenderSupply.cxx:170
 AliTRDTenderSupply.cxx:171
 AliTRDTenderSupply.cxx:172
 AliTRDTenderSupply.cxx:173
 AliTRDTenderSupply.cxx:174
 AliTRDTenderSupply.cxx:175
 AliTRDTenderSupply.cxx:176
 AliTRDTenderSupply.cxx:177
 AliTRDTenderSupply.cxx:178
 AliTRDTenderSupply.cxx:179
 AliTRDTenderSupply.cxx:180
 AliTRDTenderSupply.cxx:181
 AliTRDTenderSupply.cxx:182
 AliTRDTenderSupply.cxx:183
 AliTRDTenderSupply.cxx:184
 AliTRDTenderSupply.cxx:185
 AliTRDTenderSupply.cxx:186
 AliTRDTenderSupply.cxx:187
 AliTRDTenderSupply.cxx:188
 AliTRDTenderSupply.cxx:189
 AliTRDTenderSupply.cxx:190
 AliTRDTenderSupply.cxx:191
 AliTRDTenderSupply.cxx:192
 AliTRDTenderSupply.cxx:193
 AliTRDTenderSupply.cxx:194
 AliTRDTenderSupply.cxx:195
 AliTRDTenderSupply.cxx:196
 AliTRDTenderSupply.cxx:197
 AliTRDTenderSupply.cxx:198
 AliTRDTenderSupply.cxx:199
 AliTRDTenderSupply.cxx:200
 AliTRDTenderSupply.cxx:201
 AliTRDTenderSupply.cxx:202
 AliTRDTenderSupply.cxx:203
 AliTRDTenderSupply.cxx:204
 AliTRDTenderSupply.cxx:205
 AliTRDTenderSupply.cxx:206
 AliTRDTenderSupply.cxx:207
 AliTRDTenderSupply.cxx:208
 AliTRDTenderSupply.cxx:209
 AliTRDTenderSupply.cxx:210
 AliTRDTenderSupply.cxx:211
 AliTRDTenderSupply.cxx:212
 AliTRDTenderSupply.cxx:213
 AliTRDTenderSupply.cxx:214
 AliTRDTenderSupply.cxx:215
 AliTRDTenderSupply.cxx:216
 AliTRDTenderSupply.cxx:217
 AliTRDTenderSupply.cxx:218
 AliTRDTenderSupply.cxx:219
 AliTRDTenderSupply.cxx:220
 AliTRDTenderSupply.cxx:221
 AliTRDTenderSupply.cxx:222
 AliTRDTenderSupply.cxx:223
 AliTRDTenderSupply.cxx:224
 AliTRDTenderSupply.cxx:225
 AliTRDTenderSupply.cxx:226
 AliTRDTenderSupply.cxx:227
 AliTRDTenderSupply.cxx:228
 AliTRDTenderSupply.cxx:229
 AliTRDTenderSupply.cxx:230
 AliTRDTenderSupply.cxx:231
 AliTRDTenderSupply.cxx:232
 AliTRDTenderSupply.cxx:233
 AliTRDTenderSupply.cxx:234
 AliTRDTenderSupply.cxx:235
 AliTRDTenderSupply.cxx:236
 AliTRDTenderSupply.cxx:237
 AliTRDTenderSupply.cxx:238
 AliTRDTenderSupply.cxx:239
 AliTRDTenderSupply.cxx:240
 AliTRDTenderSupply.cxx:241
 AliTRDTenderSupply.cxx:242
 AliTRDTenderSupply.cxx:243
 AliTRDTenderSupply.cxx:244
 AliTRDTenderSupply.cxx:245
 AliTRDTenderSupply.cxx:246
 AliTRDTenderSupply.cxx:247
 AliTRDTenderSupply.cxx:248
 AliTRDTenderSupply.cxx:249
 AliTRDTenderSupply.cxx:250
 AliTRDTenderSupply.cxx:251
 AliTRDTenderSupply.cxx:252
 AliTRDTenderSupply.cxx:253
 AliTRDTenderSupply.cxx:254
 AliTRDTenderSupply.cxx:255
 AliTRDTenderSupply.cxx:256
 AliTRDTenderSupply.cxx:257
 AliTRDTenderSupply.cxx:258
 AliTRDTenderSupply.cxx:259
 AliTRDTenderSupply.cxx:260
 AliTRDTenderSupply.cxx:261
 AliTRDTenderSupply.cxx:262
 AliTRDTenderSupply.cxx:263
 AliTRDTenderSupply.cxx:264
 AliTRDTenderSupply.cxx:265
 AliTRDTenderSupply.cxx:266
 AliTRDTenderSupply.cxx:267
 AliTRDTenderSupply.cxx:268
 AliTRDTenderSupply.cxx:269
 AliTRDTenderSupply.cxx:270
 AliTRDTenderSupply.cxx:271
 AliTRDTenderSupply.cxx:272
 AliTRDTenderSupply.cxx:273
 AliTRDTenderSupply.cxx:274
 AliTRDTenderSupply.cxx:275
 AliTRDTenderSupply.cxx:276
 AliTRDTenderSupply.cxx:277
 AliTRDTenderSupply.cxx:278
 AliTRDTenderSupply.cxx:279
 AliTRDTenderSupply.cxx:280
 AliTRDTenderSupply.cxx:281
 AliTRDTenderSupply.cxx:282
 AliTRDTenderSupply.cxx:283
 AliTRDTenderSupply.cxx:284
 AliTRDTenderSupply.cxx:285
 AliTRDTenderSupply.cxx:286
 AliTRDTenderSupply.cxx:287
 AliTRDTenderSupply.cxx:288
 AliTRDTenderSupply.cxx:289
 AliTRDTenderSupply.cxx:290
 AliTRDTenderSupply.cxx:291
 AliTRDTenderSupply.cxx:292
 AliTRDTenderSupply.cxx:293
 AliTRDTenderSupply.cxx:294
 AliTRDTenderSupply.cxx:295
 AliTRDTenderSupply.cxx:296
 AliTRDTenderSupply.cxx:297
 AliTRDTenderSupply.cxx:298
 AliTRDTenderSupply.cxx:299
 AliTRDTenderSupply.cxx:300
 AliTRDTenderSupply.cxx:301
 AliTRDTenderSupply.cxx:302
 AliTRDTenderSupply.cxx:303
 AliTRDTenderSupply.cxx:304
 AliTRDTenderSupply.cxx:305
 AliTRDTenderSupply.cxx:306
 AliTRDTenderSupply.cxx:307
 AliTRDTenderSupply.cxx:308
 AliTRDTenderSupply.cxx:309
 AliTRDTenderSupply.cxx:310
 AliTRDTenderSupply.cxx:311
 AliTRDTenderSupply.cxx:312
 AliTRDTenderSupply.cxx:313
 AliTRDTenderSupply.cxx:314
 AliTRDTenderSupply.cxx:315
 AliTRDTenderSupply.cxx:316
 AliTRDTenderSupply.cxx:317
 AliTRDTenderSupply.cxx:318
 AliTRDTenderSupply.cxx:319
 AliTRDTenderSupply.cxx:320
 AliTRDTenderSupply.cxx:321
 AliTRDTenderSupply.cxx:322
 AliTRDTenderSupply.cxx:323
 AliTRDTenderSupply.cxx:324
 AliTRDTenderSupply.cxx:325
 AliTRDTenderSupply.cxx:326
 AliTRDTenderSupply.cxx:327
 AliTRDTenderSupply.cxx:328
 AliTRDTenderSupply.cxx:329
 AliTRDTenderSupply.cxx:330
 AliTRDTenderSupply.cxx:331
 AliTRDTenderSupply.cxx:332
 AliTRDTenderSupply.cxx:333
 AliTRDTenderSupply.cxx:334
 AliTRDTenderSupply.cxx:335
 AliTRDTenderSupply.cxx:336
 AliTRDTenderSupply.cxx:337
 AliTRDTenderSupply.cxx:338
 AliTRDTenderSupply.cxx:339
 AliTRDTenderSupply.cxx:340
 AliTRDTenderSupply.cxx:341
 AliTRDTenderSupply.cxx:342
 AliTRDTenderSupply.cxx:343
 AliTRDTenderSupply.cxx:344
 AliTRDTenderSupply.cxx:345
 AliTRDTenderSupply.cxx:346
 AliTRDTenderSupply.cxx:347
 AliTRDTenderSupply.cxx:348
 AliTRDTenderSupply.cxx:349
 AliTRDTenderSupply.cxx:350
 AliTRDTenderSupply.cxx:351
 AliTRDTenderSupply.cxx:352
 AliTRDTenderSupply.cxx:353
 AliTRDTenderSupply.cxx:354
 AliTRDTenderSupply.cxx:355
 AliTRDTenderSupply.cxx:356
 AliTRDTenderSupply.cxx:357
 AliTRDTenderSupply.cxx:358
 AliTRDTenderSupply.cxx:359
 AliTRDTenderSupply.cxx:360
 AliTRDTenderSupply.cxx:361
 AliTRDTenderSupply.cxx:362
 AliTRDTenderSupply.cxx:363
 AliTRDTenderSupply.cxx:364
 AliTRDTenderSupply.cxx:365
 AliTRDTenderSupply.cxx:366
 AliTRDTenderSupply.cxx:367
 AliTRDTenderSupply.cxx:368
 AliTRDTenderSupply.cxx:369
 AliTRDTenderSupply.cxx:370
 AliTRDTenderSupply.cxx:371
 AliTRDTenderSupply.cxx:372
 AliTRDTenderSupply.cxx:373
 AliTRDTenderSupply.cxx:374
 AliTRDTenderSupply.cxx:375
 AliTRDTenderSupply.cxx:376
 AliTRDTenderSupply.cxx:377
 AliTRDTenderSupply.cxx:378
 AliTRDTenderSupply.cxx:379
 AliTRDTenderSupply.cxx:380
 AliTRDTenderSupply.cxx:381
 AliTRDTenderSupply.cxx:382
 AliTRDTenderSupply.cxx:383
 AliTRDTenderSupply.cxx:384
 AliTRDTenderSupply.cxx:385
 AliTRDTenderSupply.cxx:386
 AliTRDTenderSupply.cxx:387
 AliTRDTenderSupply.cxx:388
 AliTRDTenderSupply.cxx:389
 AliTRDTenderSupply.cxx:390
 AliTRDTenderSupply.cxx:391
 AliTRDTenderSupply.cxx:392
 AliTRDTenderSupply.cxx:393
 AliTRDTenderSupply.cxx:394
 AliTRDTenderSupply.cxx:395
 AliTRDTenderSupply.cxx:396
 AliTRDTenderSupply.cxx:397
 AliTRDTenderSupply.cxx:398
 AliTRDTenderSupply.cxx:399
 AliTRDTenderSupply.cxx:400
 AliTRDTenderSupply.cxx:401
 AliTRDTenderSupply.cxx:402
 AliTRDTenderSupply.cxx:403
 AliTRDTenderSupply.cxx:404
 AliTRDTenderSupply.cxx:405
 AliTRDTenderSupply.cxx:406
 AliTRDTenderSupply.cxx:407
 AliTRDTenderSupply.cxx:408
 AliTRDTenderSupply.cxx:409
 AliTRDTenderSupply.cxx:410
 AliTRDTenderSupply.cxx:411
 AliTRDTenderSupply.cxx:412
 AliTRDTenderSupply.cxx:413
 AliTRDTenderSupply.cxx:414
 AliTRDTenderSupply.cxx:415
 AliTRDTenderSupply.cxx:416
 AliTRDTenderSupply.cxx:417
 AliTRDTenderSupply.cxx:418
 AliTRDTenderSupply.cxx:419
 AliTRDTenderSupply.cxx:420
 AliTRDTenderSupply.cxx:421
 AliTRDTenderSupply.cxx:422
 AliTRDTenderSupply.cxx:423
 AliTRDTenderSupply.cxx:424
 AliTRDTenderSupply.cxx:425
 AliTRDTenderSupply.cxx:426
 AliTRDTenderSupply.cxx:427
 AliTRDTenderSupply.cxx:428
 AliTRDTenderSupply.cxx:429
 AliTRDTenderSupply.cxx:430
 AliTRDTenderSupply.cxx:431
 AliTRDTenderSupply.cxx:432
 AliTRDTenderSupply.cxx:433
 AliTRDTenderSupply.cxx:434
 AliTRDTenderSupply.cxx:435
 AliTRDTenderSupply.cxx:436
 AliTRDTenderSupply.cxx:437
 AliTRDTenderSupply.cxx:438
 AliTRDTenderSupply.cxx:439
 AliTRDTenderSupply.cxx:440
 AliTRDTenderSupply.cxx:441
 AliTRDTenderSupply.cxx:442
 AliTRDTenderSupply.cxx:443
 AliTRDTenderSupply.cxx:444
 AliTRDTenderSupply.cxx:445
 AliTRDTenderSupply.cxx:446
 AliTRDTenderSupply.cxx:447
 AliTRDTenderSupply.cxx:448
 AliTRDTenderSupply.cxx:449
 AliTRDTenderSupply.cxx:450
 AliTRDTenderSupply.cxx:451
 AliTRDTenderSupply.cxx:452
 AliTRDTenderSupply.cxx:453
 AliTRDTenderSupply.cxx:454
 AliTRDTenderSupply.cxx:455
 AliTRDTenderSupply.cxx:456
 AliTRDTenderSupply.cxx:457
 AliTRDTenderSupply.cxx:458
 AliTRDTenderSupply.cxx:459
 AliTRDTenderSupply.cxx:460
 AliTRDTenderSupply.cxx:461
 AliTRDTenderSupply.cxx:462
 AliTRDTenderSupply.cxx:463
 AliTRDTenderSupply.cxx:464
 AliTRDTenderSupply.cxx:465
 AliTRDTenderSupply.cxx:466
 AliTRDTenderSupply.cxx:467
 AliTRDTenderSupply.cxx:468
 AliTRDTenderSupply.cxx:469
 AliTRDTenderSupply.cxx:470
 AliTRDTenderSupply.cxx:471
 AliTRDTenderSupply.cxx:472
 AliTRDTenderSupply.cxx:473
 AliTRDTenderSupply.cxx:474
 AliTRDTenderSupply.cxx:475
 AliTRDTenderSupply.cxx:476
 AliTRDTenderSupply.cxx:477
 AliTRDTenderSupply.cxx:478
 AliTRDTenderSupply.cxx:479
 AliTRDTenderSupply.cxx:480
 AliTRDTenderSupply.cxx:481
 AliTRDTenderSupply.cxx:482
 AliTRDTenderSupply.cxx:483
 AliTRDTenderSupply.cxx:484
 AliTRDTenderSupply.cxx:485
 AliTRDTenderSupply.cxx:486
 AliTRDTenderSupply.cxx:487
 AliTRDTenderSupply.cxx:488
 AliTRDTenderSupply.cxx:489
 AliTRDTenderSupply.cxx:490
 AliTRDTenderSupply.cxx:491
 AliTRDTenderSupply.cxx:492
 AliTRDTenderSupply.cxx:493
 AliTRDTenderSupply.cxx:494
 AliTRDTenderSupply.cxx:495
 AliTRDTenderSupply.cxx:496
 AliTRDTenderSupply.cxx:497
 AliTRDTenderSupply.cxx:498
 AliTRDTenderSupply.cxx:499
 AliTRDTenderSupply.cxx:500
 AliTRDTenderSupply.cxx:501
 AliTRDTenderSupply.cxx:502
 AliTRDTenderSupply.cxx:503
 AliTRDTenderSupply.cxx:504
 AliTRDTenderSupply.cxx:505
 AliTRDTenderSupply.cxx:506
 AliTRDTenderSupply.cxx:507
 AliTRDTenderSupply.cxx:508
 AliTRDTenderSupply.cxx:509
 AliTRDTenderSupply.cxx:510
 AliTRDTenderSupply.cxx:511
 AliTRDTenderSupply.cxx:512
 AliTRDTenderSupply.cxx:513
 AliTRDTenderSupply.cxx:514
 AliTRDTenderSupply.cxx:515
 AliTRDTenderSupply.cxx:516
 AliTRDTenderSupply.cxx:517
 AliTRDTenderSupply.cxx:518
 AliTRDTenderSupply.cxx:519
 AliTRDTenderSupply.cxx:520
 AliTRDTenderSupply.cxx:521
 AliTRDTenderSupply.cxx:522
 AliTRDTenderSupply.cxx:523
 AliTRDTenderSupply.cxx:524
 AliTRDTenderSupply.cxx:525
 AliTRDTenderSupply.cxx:526
 AliTRDTenderSupply.cxx:527
 AliTRDTenderSupply.cxx:528
 AliTRDTenderSupply.cxx:529
 AliTRDTenderSupply.cxx:530
 AliTRDTenderSupply.cxx:531
 AliTRDTenderSupply.cxx:532
 AliTRDTenderSupply.cxx:533
 AliTRDTenderSupply.cxx:534
 AliTRDTenderSupply.cxx:535
 AliTRDTenderSupply.cxx:536
 AliTRDTenderSupply.cxx:537
 AliTRDTenderSupply.cxx:538
 AliTRDTenderSupply.cxx:539
 AliTRDTenderSupply.cxx:540
 AliTRDTenderSupply.cxx:541
 AliTRDTenderSupply.cxx:542
 AliTRDTenderSupply.cxx:543
 AliTRDTenderSupply.cxx:544
 AliTRDTenderSupply.cxx:545
 AliTRDTenderSupply.cxx:546
 AliTRDTenderSupply.cxx:547
 AliTRDTenderSupply.cxx:548
 AliTRDTenderSupply.cxx:549
 AliTRDTenderSupply.cxx:550
 AliTRDTenderSupply.cxx:551
 AliTRDTenderSupply.cxx:552
 AliTRDTenderSupply.cxx:553
 AliTRDTenderSupply.cxx:554
 AliTRDTenderSupply.cxx:555
 AliTRDTenderSupply.cxx:556
 AliTRDTenderSupply.cxx:557
 AliTRDTenderSupply.cxx:558
 AliTRDTenderSupply.cxx:559
 AliTRDTenderSupply.cxx:560
 AliTRDTenderSupply.cxx:561
 AliTRDTenderSupply.cxx:562
 AliTRDTenderSupply.cxx:563
 AliTRDTenderSupply.cxx:564
 AliTRDTenderSupply.cxx:565
 AliTRDTenderSupply.cxx:566
 AliTRDTenderSupply.cxx:567
 AliTRDTenderSupply.cxx:568
 AliTRDTenderSupply.cxx:569
 AliTRDTenderSupply.cxx:570
 AliTRDTenderSupply.cxx:571
 AliTRDTenderSupply.cxx:572
 AliTRDTenderSupply.cxx:573
 AliTRDTenderSupply.cxx:574
 AliTRDTenderSupply.cxx:575
 AliTRDTenderSupply.cxx:576
 AliTRDTenderSupply.cxx:577
 AliTRDTenderSupply.cxx:578
 AliTRDTenderSupply.cxx:579
 AliTRDTenderSupply.cxx:580
 AliTRDTenderSupply.cxx:581
 AliTRDTenderSupply.cxx:582
 AliTRDTenderSupply.cxx:583
 AliTRDTenderSupply.cxx:584
 AliTRDTenderSupply.cxx:585
 AliTRDTenderSupply.cxx:586
 AliTRDTenderSupply.cxx:587
 AliTRDTenderSupply.cxx:588
 AliTRDTenderSupply.cxx:589
 AliTRDTenderSupply.cxx:590
 AliTRDTenderSupply.cxx:591
 AliTRDTenderSupply.cxx:592
 AliTRDTenderSupply.cxx:593
 AliTRDTenderSupply.cxx:594
 AliTRDTenderSupply.cxx:595
 AliTRDTenderSupply.cxx:596
 AliTRDTenderSupply.cxx:597
 AliTRDTenderSupply.cxx:598
 AliTRDTenderSupply.cxx:599
 AliTRDTenderSupply.cxx:600
 AliTRDTenderSupply.cxx:601
 AliTRDTenderSupply.cxx:602
 AliTRDTenderSupply.cxx:603
 AliTRDTenderSupply.cxx:604
 AliTRDTenderSupply.cxx:605
 AliTRDTenderSupply.cxx:606
 AliTRDTenderSupply.cxx:607
 AliTRDTenderSupply.cxx:608
 AliTRDTenderSupply.cxx:609
 AliTRDTenderSupply.cxx:610
 AliTRDTenderSupply.cxx:611
 AliTRDTenderSupply.cxx:612
 AliTRDTenderSupply.cxx:613
 AliTRDTenderSupply.cxx:614
 AliTRDTenderSupply.cxx:615
 AliTRDTenderSupply.cxx:616
 AliTRDTenderSupply.cxx:617
 AliTRDTenderSupply.cxx:618
 AliTRDTenderSupply.cxx:619
 AliTRDTenderSupply.cxx:620
 AliTRDTenderSupply.cxx:621
 AliTRDTenderSupply.cxx:622
 AliTRDTenderSupply.cxx:623
 AliTRDTenderSupply.cxx:624
 AliTRDTenderSupply.cxx:625
 AliTRDTenderSupply.cxx:626
 AliTRDTenderSupply.cxx:627
 AliTRDTenderSupply.cxx:628
 AliTRDTenderSupply.cxx:629
 AliTRDTenderSupply.cxx:630
 AliTRDTenderSupply.cxx:631
 AliTRDTenderSupply.cxx:632
 AliTRDTenderSupply.cxx:633
 AliTRDTenderSupply.cxx:634
 AliTRDTenderSupply.cxx:635
 AliTRDTenderSupply.cxx:636
 AliTRDTenderSupply.cxx:637
 AliTRDTenderSupply.cxx:638
 AliTRDTenderSupply.cxx:639
 AliTRDTenderSupply.cxx:640
 AliTRDTenderSupply.cxx:641
 AliTRDTenderSupply.cxx:642
 AliTRDTenderSupply.cxx:643
 AliTRDTenderSupply.cxx:644
 AliTRDTenderSupply.cxx:645
 AliTRDTenderSupply.cxx:646
 AliTRDTenderSupply.cxx:647
 AliTRDTenderSupply.cxx:648
 AliTRDTenderSupply.cxx:649
 AliTRDTenderSupply.cxx:650
 AliTRDTenderSupply.cxx:651