ROOT logo
#include "TChain.h"
#include "TList.h"
#include "TCanvas.h"
#include "TLorentzVector.h"
#include "TGraphErrors.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TH3F.h" 
#include "TH2D.h"                  
#include "TH3D.h"
#include "TArrayF.h"
#include "TF1.h"
#include "TRandom.h"
#include "TROOT.h"

#include "AliAnalysisTaskSE.h"
#include "AliAnalysisManager.h"

#include "AliESDVertex.h"
#include "AliESDEvent.h"
#include "AliESDInputHandler.h"
#include "AliAODEvent.h"
#include "AliAODTrack.h"
#include "AliAODInputHandler.h"
#include "AliAODMCParticle.h" 
#include "AliCollisionGeometry.h"
#include "AliGenEventHeader.h"
#include "AliMCEventHandler.h"
#include "AliMCEvent.h"
#include "AliStack.h"
#include "AliESDtrackCuts.h"
#include "AliEventplane.h"
#include "AliTHn.h"    
#include "AliLog.h"
#include "AliAnalysisUtils.h"

#include "AliEventPoolManager.h"           

#include "AliPID.h"                
#include "AliPIDResponse.h"        
#include "AliPIDCombined.h"        

#include "AliAnalysisTaskBFPsi.h"
#include "AliBalancePsi.h"
#include "AliAnalysisTaskTriggeredBF.h"


// Analysis task for the BF vs Psi code
// Authors: Panos.Christakoglou@nikhef.nl

using std::cout;
using std::endl;

ClassImp(AliAnalysisTaskBFPsi)

//________________________________________________________________________
AliAnalysisTaskBFPsi::AliAnalysisTaskBFPsi(const char *name) 
: AliAnalysisTaskSE(name),
  fDebugLevel(kFALSE),
  fArrayMC(0),
  fBalance(0),
  fRunShuffling(kFALSE),
  fShuffledBalance(0),
  fRunMixing(kFALSE),
  fRunMixingEventPlane(kFALSE),
  fMixingTracks(50000),
  fMixedBalance(0),
  fPoolMgr(0),
  fList(0),
  fListBF(0),
  fListBFS(0),
  fListBFM(0),
  fHistListPIDQA(0),
  fHistEventStats(0),
  fHistCentStats(0),
  fHistCentStatsUsed(0),
  fHistTriggerStats(0),
  fHistTrackStats(0),
  fHistVx(0),
  fHistVy(0),
  fHistVz(0),
  fHistTPCvsVZEROMultiplicity(0),
  fHistVZEROSignal(0),
  fHistEventPlane(0),
  fHistClus(0),
  fHistDCA(0),
  fHistChi2(0),
  fHistPt(0),
  fHistEta(0),
  fHistRapidity(0),
  fHistPhi(0),
  fHistEtaPhiPos(0), 	       	 
  fHistEtaPhiNeg(0), 
  fHistPhiBefore(0),
  fHistPhiAfter(0),
  fHistPhiPos(0),
  fHistPhiNeg(0),
  fHistV0M(0),
  fHistRefTracks(0),
  fHistdEdxVsPTPCbeforePID(NULL),
  fHistBetavsPTOFbeforePID(NULL), 
  fHistProbTPCvsPtbeforePID(NULL), 
  fHistProbTOFvsPtbeforePID(NULL), 
  fHistProbTPCTOFvsPtbeforePID(NULL),
  fHistNSigmaTPCvsPtbeforePID(NULL), 
  fHistNSigmaTOFvsPtbeforePID(NULL), 
  fHistBetaVsdEdXbeforePID(NULL),
  fHistNSigmaTPCTOFvsPtbeforePID(NULL),
  fHistNSigmaTPCTOFPbefPID(NULL),
  fHistdEdxVsPTPCafterPID(NULL),
  fHistBetavsPTOFafterPID(NULL), 
  fHistProbTPCvsPtafterPID(NULL), 
  fHistProbTOFvsPtafterPID(NULL), 
  fHistProbTPCTOFvsPtafterPID(NULL),
  fHistNSigmaTPCvsPtafterPID(NULL), 
  fHistNSigmaTOFvsPtafterPID(NULL),  
  fHistBetaVsdEdXafterPID(NULL), 
  fHistNSigmaTPCTOFvsPtafterPID(NULL),
  fHistNSigmaTPCTOFPafterPID(NULL),
  fHistdEdxVsPTPCbeforePIDelectron(NULL),
  fHistNSigmaTPCvsPtbeforePIDelectron(NULL),
  fHistdEdxVsPTPCafterPIDelectron(NULL),
  fHistNSigmaTPCvsPtafterPIDelectron(NULL),
  fCentralityArrayBinsForCorrections(kCENTRALITY),
  fCentralityWeights(0x0),
  fPIDResponse(0x0),
  fPIDCombined(0x0),
  fParticleOfInterest(kPion),
  fPidDetectorConfig(kTPCTOF),
  fUsePID(kFALSE),
  fUsePIDnSigma(kTRUE),
  fUsePIDPropabilities(kFALSE), 
  fPIDNSigma(3.),
  fMinAcceptedPIDProbability(0.8),
  fElectronRejection(kFALSE),
  fElectronOnlyRejection(kFALSE),
  fElectronRejectionNSigma(-1.),
  fElectronRejectionMinPt(0.),
  fElectronRejectionMaxPt(1000.),
  fESDtrackCuts(0),
  fCentralityEstimator("V0M"),
  fUseCentrality(kFALSE),
  fCentralityPercentileMin(0.), 
  fCentralityPercentileMax(5.),
  fImpactParameterMin(0.),
  fImpactParameterMax(20.),
  fMultiplicityEstimator("V0A"),
  fUseMultiplicity(kFALSE),
  fNumberOfAcceptedTracksMin(0),
  fNumberOfAcceptedTracksMax(10000),
  fHistNumberOfAcceptedTracks(0),
  fHistMultiplicity(0),
  fUseOfflineTrigger(kFALSE),
  fCheckFirstEventInChunk(kFALSE),
  fCheckPileUp(kFALSE),
  fCheckPrimaryFlagAOD(kFALSE),
  fUseMCforKinematics(kFALSE),
  fVxMax(0.3),
  fVyMax(0.3),
  fVzMax(10.),
  fnAODtrackCutBit(128),
  fPtMin(0.3),
  fPtMax(1.5),
  fEtaMin(-0.8),
  fEtaMax(0.8),
  fPhiMin(0.),
  fPhiMax(360.),
  fDCAxyCut(-1),
  fDCAzCut(-1),
  fTPCchi2Cut(-1),
  fNClustersTPCCut(-1),
  fTPCsharedCut(-1),
  fAcceptanceParameterization(0),
  fDifferentialV2(0),
  fUseFlowAfterBurner(kFALSE),
  fExcludeResonancesInMC(kFALSE),
  fExcludeElectronsInMC(kFALSE),
  fUseMCPdgCode(kFALSE),
  fPDGCodeToBeAnalyzed(-1),
  fEventClass("EventPlane"), 
  fCustomBinning(""),
  fHistVZEROAGainEqualizationMap(0),
  fHistVZEROCGainEqualizationMap(0),
  fHistVZEROChannelGainEqualizationMap(0) {
  // Constructor
  // Define input and output slots here
  // Input slot #0 works with a TChain

  //======================================================correction
  for (Int_t i=0; i<kCENTRALITY; i++){
    fHistCorrectionPlus[i] = NULL; 
    fHistCorrectionMinus[i] = NULL; 
    fCentralityArrayForCorrections[i] = -1.;
  }
  //=====================================================correction

  DefineInput(0, TChain::Class());
  // Output slot #0 writes into a TH1 container
  DefineOutput(1, TList::Class());
  DefineOutput(2, TList::Class());
  DefineOutput(3, TList::Class());
  DefineOutput(4, TList::Class());
  DefineOutput(5, TList::Class());
}

//________________________________________________________________________
AliAnalysisTaskBFPsi::~AliAnalysisTaskBFPsi() {

  // delete fBalance; 
  // delete fShuffledBalance; 
  // delete fList;
  // delete fListBF; 
  // delete fListBFS;

  // delete fHistEventStats; 
  // delete fHistTrackStats; 
  // delete fHistVx; 
  // delete fHistVy; 
  // delete fHistVz; 

  // delete fHistClus;
  // delete fHistDCA;
  // delete fHistChi2;
  // delete fHistPt;
  // delete fHistEta;
  // delete fHistPhi;
  // delete fHistEtaPhiPos; 		 	 
  // delete fHistEtaPhiNeg;
  // delete fHistV0M;
}

//________________________________________________________________________
void AliAnalysisTaskBFPsi::UserCreateOutputObjects() {
  // Create histograms
  // Called once

  // global switch disabling the reference 
  // (to avoid "Replacing existing TH1" if several wagons are created in train)
  Bool_t oldStatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);

  if(!fBalance) {
    fBalance = new AliBalancePsi();
    fBalance->SetAnalysisLevel("ESD");
    fBalance->SetEventClass(fEventClass);
    //fBalance->SetNumberOfBins(-1,16);
    //fBalance->SetInterval(-1,-0.8,0.8,16,0.,1.6,15.);
  }
  if(fRunShuffling) {
    if(!fShuffledBalance) {
      fShuffledBalance = new AliBalancePsi();
      fShuffledBalance->SetAnalysisLevel("ESD");
      fShuffledBalance->SetEventClass(fEventClass);
      //fShuffledBalance->SetNumberOfBins(-1,16);
      //fShuffledBalance->SetInterval(-1,-0.8,0.8,16,0.,1.6,15.);
    }
  }
  if(fRunMixing) {
    if(!fMixedBalance) {
      fMixedBalance = new AliBalancePsi();
      fMixedBalance->SetAnalysisLevel("ESD");
      fMixedBalance->SetEventClass(fEventClass);
    }
  }

  //QA list
  fList = new TList();
  fList->SetName("listQA");
  fList->SetOwner();

  //Balance Function list
  fListBF = new TList();
  fListBF->SetName("listBF");
  fListBF->SetOwner();

  if(fRunShuffling) {
    fListBFS = new TList();
    fListBFS->SetName("listBFShuffled");
    fListBFS->SetOwner();
  }

  if(fRunMixing) {
    fListBFM = new TList();
    fListBFM->SetName("listTriggeredBFMixed");
    fListBFM->SetOwner();
  }

  //PID QA list
  if(fUsePID || fElectronRejection) {
    fHistListPIDQA = new TList();
    fHistListPIDQA->SetName("listQAPID");
    fHistListPIDQA->SetOwner();
  }

  //Event stats.
  TString gCutName[7] = {"Total","Offline trigger",
                         "Vertex","Analyzed","sel. Centrality","Not1stEvInChunk","No Pile-Up"};
  fHistEventStats = new TH2F("fHistEventStats",
                             "Event statistics;;Centrality percentile;N_{events}",
                             7,0.5,7.5,220,-5,105);
  for(Int_t i = 1; i <= 7; i++)
    fHistEventStats->GetXaxis()->SetBinLabel(i,gCutName[i-1].Data());
  fList->Add(fHistEventStats);

  TString gCentName[13] = {"V0M","V0A","V0C","FMD","TRK","TKL","CL0","CL1","ZNA","ZPA","V0MvsFMD","TKLvsV0M","ZEMvsZDC"};
  fHistCentStats = new TH2F("fHistCentStats",
                             "Centrality statistics;;Cent percentile",
			    13,-0.5,12.5,220,-5,105);
  for(Int_t i = 1; i <= 13; i++){
    fHistCentStats->GetXaxis()->SetBinLabel(i,gCentName[i-1].Data());
    //fHistCentStatsUsed->GetXaxis()->SetBinLabel(i,gCentName[i-1].Data());
  }
  fList->Add(fHistCentStats);

  fHistCentStatsUsed = new TH2F("fHistCentStatsUsed","Centrality statistics;;Cent percentile", 1,-0.5,0.5,220,-5,105);
  fHistCentStatsUsed->GetXaxis()->SetBinLabel(1,fCentralityEstimator.Data());
  fList->Add(fHistCentStatsUsed);

  fHistTriggerStats = new TH1F("fHistTriggerStats","Trigger statistics;TriggerBit;N_{events}",1025,0,1025);
  fList->Add(fHistTriggerStats);

  fHistTrackStats = new TH1F("fHistTrackStats","Event statistics;TrackFilterBit;N_{events}",16,0,16);
  fList->Add(fHistTrackStats);

  fHistNumberOfAcceptedTracks = new TH2F("fHistNumberOfAcceptedTracks",";N_{acc.};Centrality percentile;Entries",4001,-0.5,4000.5,220,-5,105);
  fList->Add(fHistNumberOfAcceptedTracks);

  fHistMultiplicity = new TH1F("fHistMultiplicity",";N_{ch.};Entries",30001,-0.5,30000.5);
  fList->Add(fHistMultiplicity);

  // Vertex distributions
  fHistVx = new TH1F("fHistVx","Primary vertex distribution - x coordinate;V_{x} (cm);Entries",100,-0.5,0.5);
  fList->Add(fHistVx);
  fHistVy = new TH1F("fHistVy","Primary vertex distribution - y coordinate;V_{y} (cm);Entries",100,-0.5,0.5);
  fList->Add(fHistVy);
  fHistVz = new TH2F("fHistVz","Primary vertex distribution - z coordinate;V_{z} (cm);Centrality percentile;Entries",100,-20.,20.,220,-5,105);
  fList->Add(fHistVz);

  //TPC vs VZERO multiplicity
  fHistTPCvsVZEROMultiplicity = new TH2F("fHistTPCvsVZEROMultiplicity","VZERO vs TPC multiplicity",10001,-0.5,10000.5,4001,-0.5,4000.5);
  if(fMultiplicityEstimator == "V0A") 
    fHistTPCvsVZEROMultiplicity->GetXaxis()->SetTitle("VZERO-A multiplicity (a.u.)");
  else if(fMultiplicityEstimator == "V0C") 
    fHistTPCvsVZEROMultiplicity->GetXaxis()->SetTitle("VZERO-C multiplicity (a.u.)");
  else 
    fHistTPCvsVZEROMultiplicity->GetXaxis()->SetTitle("VZERO multiplicity (a.u.)");
  fList->Add(fHistTPCvsVZEROMultiplicity);

  fHistVZEROSignal = new TH2F("fHistVZEROSignal","VZERO signal vs VZERO channel;VZERO channel; Signal (a.u.)",64,0.5,64.5,3001,-0.5,30000.5);
  fList->Add(fHistVZEROSignal);

  //Event plane
  fHistEventPlane = new TH2F("fHistEventPlane",";#Psi_{2} [deg.];Centrality percentile;Counts",100,0,360.,220,-5,105);
  fList->Add(fHistEventPlane);

  // QA histograms
  fHistClus = new TH2F("fHistClus","# Cluster (TPC vs. ITS)",10,0,10,200,0,200);
  fList->Add(fHistClus);
  fHistChi2 = new TH2F("fHistChi2","Chi2/NDF distribution;#chi^{2}/ndf;Centrality percentile",200,0,10,220,-5,105);
  fList->Add(fHistChi2);
  fHistDCA  = new TH2F("fHistDCA","DCA (xy vs. z)",400,-5,5,400,-5,5); 
  fList->Add(fHistDCA);
  fHistPt   = new TH2F("fHistPt","p_{T} distribution;p_{T} (GeV/c);Centrality percentile",200,0,10,220,-5,105);
  fList->Add(fHistPt);
  fHistEta  = new TH2F("fHistEta","#eta distribution;#eta;Centrality percentile",200,-2,2,220,-5,105);
  fList->Add(fHistEta);
  fHistRapidity  = new TH2F("fHistRapidity","y distribution;y;Centrality percentile",200,-2,2,220,-5,105);
  fList->Add(fHistRapidity);
  fHistPhi  = new TH2F("fHistPhi","#phi distribution;#phi (rad);Centrality percentile",200,0.0,2.*TMath::Pi(),220,-5,105);
  fList->Add(fHistPhi);
  fHistEtaPhiPos  = new TH3F("fHistEtaPhiPos","#eta-#phi distribution (+);#eta;#phi (rad);Centrality percentile",40,-1.6,1.6,72,0.,2.*TMath::Pi(),220,-5,105); 		 	 
  fList->Add(fHistEtaPhiPos); 			 
  fHistEtaPhiNeg  = new TH3F("fHistEtaPhiNeg","#eta-#phi distribution (-);#eta;#phi (rad);Centrality percentile",40,-1.6,1.6,72,0.,2.*TMath::Pi(),220,-5,105); 	       	 
  fList->Add(fHistEtaPhiNeg);
  fHistPhiBefore  = new TH2F("fHistPhiBefore","#phi distribution;#phi;Centrality percentile",200,0.,2*TMath::Pi(),220,-5,105);
  fList->Add(fHistPhiBefore);
  fHistPhiAfter  = new TH2F("fHistPhiAfter","#phi distribution;#phi;Centrality percentile",200,0.,2*TMath::Pi(),220,-5,105);
  fList->Add(fHistPhiAfter);
  fHistPhiPos  = new TH2F("fHistPhiPos","#phi distribution for positive particles;#phi;Centrality percentile",200,0.,2*TMath::Pi(),220,-5,105);
  fList->Add(fHistPhiPos);
  fHistPhiNeg  = new TH2F("fHistPhiNeg","#phi distribution for negative particles;#phi;Centrality percentile",200,0.,2.*TMath::Pi(),220,-5,105);
  fList->Add(fHistPhiNeg);
  fHistV0M  = new TH2F("fHistV0M","V0 Multiplicity C vs. A",500, 0, 20000, 500, 0, 20000);
  fList->Add(fHistV0M);
  TString gRefTrackName[6] = {"tracks","tracksPos","tracksNeg","tracksTPConly","clusITS0","clusITS1"};
  fHistRefTracks  = new TH2F("fHistRefTracks","Nr of Ref tracks/event vs. ref track estimator;;Nr of tracks",6, 0, 6, 400, 0, 20000);
  for(Int_t i = 1; i <= 6; i++)
    fHistRefTracks->GetXaxis()->SetBinLabel(i,gRefTrackName[i-1].Data());
  fList->Add(fHistRefTracks);

  // Balance function histograms
  // Initialize histograms if not done yet (including the custom binning)
  if(!fBalance->GetHistNp()){
    AliInfo("Histograms not yet initialized! --> Will be done now");
    fBalance->SetCustomBinning(fCustomBinning);
    fBalance->InitHistograms();
  }

  if(fRunShuffling) {
    if(!fShuffledBalance->GetHistNp()) {
      AliInfo("Histograms (shuffling) not yet initialized! --> Will be done now");
      fShuffledBalance->SetCustomBinning(fCustomBinning);
      fShuffledBalance->InitHistograms();
    }
  }

  if(fRunMixing) {
    if(!fMixedBalance->GetHistNp()) {
      AliInfo("Histograms (mixing) not yet initialized! --> Will be done now");
      fMixedBalance->SetCustomBinning(fCustomBinning);
      fMixedBalance->InitHistograms();
    }
  }

  // QA histograms for different cuts
  fList->Add(fBalance->GetQAHistHBTbefore());
  fList->Add(fBalance->GetQAHistHBTafter());
  fList->Add(fBalance->GetQAHistConversionbefore());
  fList->Add(fBalance->GetQAHistConversionafter());
  fList->Add(fBalance->GetQAHistPsiMinusPhi());
  fList->Add(fBalance->GetQAHistResonancesBefore());
  fList->Add(fBalance->GetQAHistResonancesRho());
  fList->Add(fBalance->GetQAHistResonancesK0());
  fList->Add(fBalance->GetQAHistResonancesLambda());
  fList->Add(fBalance->GetQAHistQbefore());
  fList->Add(fBalance->GetQAHistQafter());

  //for(Int_t a = 0; a < ANALYSIS_TYPES; a++){
  fListBF->Add(fBalance->GetHistNp());
  fListBF->Add(fBalance->GetHistNn());
  fListBF->Add(fBalance->GetHistNpn());
  fListBF->Add(fBalance->GetHistNnn());
  fListBF->Add(fBalance->GetHistNpp());
  fListBF->Add(fBalance->GetHistNnp());

  if(fRunShuffling) {
    fListBFS->Add(fShuffledBalance->GetHistNp());
    fListBFS->Add(fShuffledBalance->GetHistNn());
    fListBFS->Add(fShuffledBalance->GetHistNpn());
    fListBFS->Add(fShuffledBalance->GetHistNnn());
    fListBFS->Add(fShuffledBalance->GetHistNpp());
    fListBFS->Add(fShuffledBalance->GetHistNnp());
  }  

  if(fRunMixing) {
    fListBFM->Add(fMixedBalance->GetHistNp());
    fListBFM->Add(fMixedBalance->GetHistNn());
    fListBFM->Add(fMixedBalance->GetHistNpn());
    fListBFM->Add(fMixedBalance->GetHistNnn());
    fListBFM->Add(fMixedBalance->GetHistNpp());
    fListBFM->Add(fMixedBalance->GetHistNnp());
  }
  //}


  // Event Mixing
  if(fRunMixing){
    Int_t trackDepth = fMixingTracks; 
    Int_t poolsize   = 1000;  // Maximum number of events, ignored in the present implemented of AliEventPoolManager
    
    // centrality bins
    Double_t* centbins = NULL;
    Int_t nCentralityBins;
    if(fBalance->IsUseVertexBinning()){
      centbins = fBalance->GetBinning(fBalance->GetBinningString(), "centralityVertex", nCentralityBins);
    }
    else{
      centbins = fBalance->GetBinning(fBalance->GetBinningString(), "centrality", nCentralityBins);
    }
    
    // multiplicity bins
    Double_t* multbins = NULL;
    Int_t nMultiplicityBins;
    multbins = fBalance->GetBinning(fBalance->GetBinningString(), "multiplicity", nMultiplicityBins);
    
    // Zvtx bins
    Double_t* vtxbins = NULL; 
    Int_t nVertexBins;
    if(fBalance->IsUseVertexBinning()){
      vtxbins = fBalance->GetBinning(fBalance->GetBinningString(), "vertexVertex", nVertexBins);
    }
    else{
      vtxbins = fBalance->GetBinning(fBalance->GetBinningString(), "vertex", nVertexBins);
    }

    // Event plane angle (Psi) bins
    Double_t* psibins = NULL;
    Int_t nPsiBins; 
    psibins = fBalance->GetBinning(fBalance->GetBinningString(), "eventPlane", nPsiBins);

  
    // run the event mixing also in bins of event plane (statistics!)
    if(fRunMixingEventPlane){
      if(fEventClass=="Multiplicity"){
	if(multbins && vtxbins && psibins){
	  fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nMultiplicityBins, multbins, nVertexBins, vtxbins, nPsiBins, psibins);
	}
      }
      else{
	if(centbins && vtxbins && psibins){
	  fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBins, centbins, nVertexBins, vtxbins, nPsiBins, psibins);
	}
      }
    }
    else{
      if(fEventClass=="Multiplicity"){
	if(multbins && vtxbins){
	  fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nMultiplicityBins, multbins, nVertexBins, vtxbins);
	}
      }
      else{
	if(centbins && vtxbins){
	  fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBins, centbins, nVertexBins, vtxbins);
	}
      }
    }
    
    if(centbins) delete [] centbins; 
    if(multbins) delete [] multbins; 
    if(vtxbins)  delete [] vtxbins; 
    if(psibins)  delete [] psibins; 
    
    // check pool manager
    if(!fPoolMgr){
      AliError("Event Mixing required, but Pool Manager not initialized...");
      return;
    }
  }
  
  if(fESDtrackCuts) fList->Add(fESDtrackCuts);

  //====================PID========================//
  if(fUsePID) {
    fPIDCombined = new AliPIDCombined();
    fPIDCombined->SetDefaultTPCPriors();

    fHistdEdxVsPTPCbeforePID = new TH2D ("dEdxVsPTPCbefore","dEdxVsPTPCbefore", 1000, -10.0, 10.0, 1000, 0, 1000); 
    fHistListPIDQA->Add(fHistdEdxVsPTPCbeforePID);
    
    fHistBetavsPTOFbeforePID = new TH2D ("BetavsPTOFbefore","BetavsPTOFbefore", 1000, -10.0, 10., 1000, 0, 1.2); 
    fHistListPIDQA->Add(fHistBetavsPTOFbeforePID); 
    
    fHistProbTPCvsPtbeforePID = new TH2D ("ProbTPCvsPtbefore","ProbTPCvsPtbefore", 1000, -10.0,10.0, 1000, 0, 2.0); 
    fHistListPIDQA->Add(fHistProbTPCvsPtbeforePID); 
    
    fHistProbTOFvsPtbeforePID = new TH2D ("ProbTOFvsPtbefore","ProbTOFvsPtbefore", 1000, -50, 50, 1000, 0, 2.0); 
    fHistListPIDQA->Add(fHistProbTOFvsPtbeforePID);

    fHistProbTPCTOFvsPtbeforePID =new TH2D ("ProbTPCTOFvsPtbefore","ProbTPCTOFvsPtbefore", 1000, -50, 50, 1000, 0, 2.0); 
    fHistListPIDQA->Add(fHistProbTPCTOFvsPtbeforePID);
    
    fHistNSigmaTPCvsPtbeforePID = new TH2D ("NSigmaTPCvsPtbefore","NSigmaTPCvsPtbefore", 1000, -10, 10, 1000, -25, 25); 
    fHistListPIDQA->Add(fHistNSigmaTPCvsPtbeforePID);
    
    fHistNSigmaTOFvsPtbeforePID = new TH2D ("NSigmaTOFvsPtbefore","NSigmaTOFvsPtbefore", 1000, -10, 10, 1000, -25, 25); 
    fHistListPIDQA->Add(fHistNSigmaTOFvsPtbeforePID); 

    fHistBetaVsdEdXbeforePID = new TH2D ("BetaVsdEdXbefore","BetaVsdEdXbefore", 1000, 0., 1000, 1000, 0, 1.2); 
    fHistListPIDQA->Add(fHistBetaVsdEdXbeforePID);
    
    fHistNSigmaTPCTOFvsPtbeforePID = new TH2D ("NSigmaTPCTOFvsPtbefore","NSigmaTPCTOFvsPtbefore", 1000, -10., 10., 1000, -25, 25); 
    fHistListPIDQA->Add(fHistNSigmaTPCTOFvsPtbeforePID);
    
    //+++++++++++++++++//
    //p array
    const Int_t pBins = 36;
    Double_t nArrayP[pBins+1]={0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 7.0, 8.0, 9.0, 10.0, 15.0, 20.0};
    //nSigma Array
    const Int_t nSigmaBins = 250;
    Double_t nArrayS[nSigmaBins+1];
    for (Int_t i = 0; i <= nSigmaBins; i++){
      nArrayS[i]=i-125; //i+1
      //Printf("nS: %lf - i: %d", nSigmaArray[i], i);
    }
 
    fHistNSigmaTPCTOFPbefPID = new TH3D ("fHistNSigmaTPCTOFPbefPID","fHistNSigmaTPCTOFPbefPID;#sigma_{TPC};#sigma_{TOF};p_{T} (GeV/c)", nSigmaBins, nArrayS, nSigmaBins, nArrayS, pBins,nArrayP); 
    fHistListPIDQA->Add(fHistNSigmaTPCTOFPbefPID); 
    //++++++++++++++//

    fHistdEdxVsPTPCafterPID = new TH2D ("dEdxVsPTPCafter","dEdxVsPTPCafter", 1000, -10, 10, 1000, 0, 1000); 
    fHistListPIDQA->Add(fHistdEdxVsPTPCafterPID);
    
    fHistBetavsPTOFafterPID = new TH2D ("BetavsPTOFafter","BetavsPTOFafter", 1000, -10, 10, 1000, 0, 1.2); 
    fHistListPIDQA->Add(fHistBetavsPTOFafterPID); 
    
    fHistProbTPCvsPtafterPID = new TH2D ("ProbTPCvsPtafter","ProbTPCvsPtafter", 1000, -10, 10, 1000, 0, 2); 
    fHistListPIDQA->Add(fHistProbTPCvsPtafterPID);
  
    fHistProbTOFvsPtafterPID = new TH2D ("ProbTOFvsPtafter","ProbTOFvsPtafter", 1000,  -10, 10, 1000, 0, 2); 
    fHistListPIDQA->Add(fHistProbTOFvsPtafterPID); 
    
    fHistProbTPCTOFvsPtafterPID =new TH2D ("ProbTPCTOFvsPtafter","ProbTPCTOFvsPtafter", 1000, -50, 50, 1000, 0, 2.0); 
    fHistListPIDQA->Add(fHistProbTPCTOFvsPtafterPID);

    fHistNSigmaTPCvsPtafterPID = new TH2D ("NSigmaTPCvsPtafter","NSigmaTPCvsPtafter", 1000, -10, 10, 1000, -25, 25); 
    fHistListPIDQA->Add(fHistNSigmaTPCvsPtafterPID);
    
    fHistNSigmaTOFvsPtafterPID = new TH2D ("NSigmaTOFvsPtafter","NSigmaTOFvsPtafter", 1000, -10, 10, 1000, -25, 25); 
    fHistListPIDQA->Add(fHistNSigmaTOFvsPtafterPID);

    fHistBetaVsdEdXafterPID = new TH2D ("BetaVsdEdXafter","BetaVsdEdXafter", 1000, 0., 1000, 1000, 0, 1.2); 
    fHistListPIDQA->Add(fHistBetaVsdEdXafterPID);

    fHistNSigmaTPCTOFvsPtafterPID = new TH2D ("NSigmaTPCTOFvsPtafter","NSigmaTPCTOFvsPtafter", 1000, -10., 10., 1000, -25, 25); 
    fHistListPIDQA->Add(fHistNSigmaTPCTOFvsPtafterPID);

    fHistNSigmaTPCTOFPafterPID = new TH3D ("fHistNSigmaTPCTOFPafterPID","fHistNSigmaTPCTOFPafterPID;#sigma_{TPC};#sigma_{TOF};p_{T} (GeV/c)", nSigmaBins, nArrayS, nSigmaBins, nArrayS, pBins,nArrayP); 
    fHistListPIDQA->Add(fHistNSigmaTPCTOFPafterPID); //++++++++++++++
  }

  // for electron rejection only TPC nsigma histograms
  if(fElectronRejection) {
 
    fHistdEdxVsPTPCbeforePIDelectron = new TH2D ("dEdxVsPTPCbeforeelectron","dEdxVsPTPCbeforeelectron", 1000, -10.0, 10.0, 1000, 0, 1000); 
    fHistListPIDQA->Add(fHistdEdxVsPTPCbeforePIDelectron);
    
    fHistNSigmaTPCvsPtbeforePIDelectron = new TH2D ("NSigmaTPCvsPtbeforeelectron","NSigmaTPCvsPtbeforeelectron", 1000, -10, 10, 1000, 0, 500); 
    fHistListPIDQA->Add(fHistNSigmaTPCvsPtbeforePIDelectron);
    
    fHistdEdxVsPTPCafterPIDelectron = new TH2D ("dEdxVsPTPCafterelectron","dEdxVsPTPCafterelectron", 1000, -10, 10, 1000, 0, 1000); 
    fHistListPIDQA->Add(fHistdEdxVsPTPCafterPIDelectron);

    fHistNSigmaTPCvsPtafterPIDelectron = new TH2D ("NSigmaTPCvsPtafterelectron","NSigmaTPCvsPtafterelectron", 1000, -10, 10, 1000, 0, 500); 
    fHistListPIDQA->Add(fHistNSigmaTPCvsPtafterPIDelectron); 
  }
  //====================PID========================//

  // Post output data.
  PostData(1, fList);
  PostData(2, fListBF);
  if(fRunShuffling) PostData(3, fListBFS);
  if(fRunMixing) PostData(4, fListBFM);
  if(fUsePID || fElectronRejection) PostData(5, fHistListPIDQA);       //PID

  AliInfo("Finished setting up the Output");

  TH1::AddDirectory(oldStatus);

}


//________________________________________________________________________
void AliAnalysisTaskBFPsi::SetInputCorrection(TString filename, 
					      Int_t nCentralityBins, 
					      Double_t *centralityArrayForCorrections) {
  //Open files that will be used for correction
  fCentralityArrayBinsForCorrections = nCentralityBins;
  for (Int_t i=0; i<nCentralityBins; i++)
    fCentralityArrayForCorrections[i] = centralityArrayForCorrections[i];

  // No file specified -> run without corrections
  if(!filename.Contains(".root")) {
    AliInfo(Form("No correction file specified (= %s) --> run without corrections",filename.Data()));
    return;
  }

  //Open the input file
  TFile *f = TFile::Open(filename);
  if(!f->IsOpen()) {
    AliInfo(Form("File %s not found --> run without corrections",filename.Data()));
    return;
  }
    
  //TString listEffName = "";
  for (Int_t iCent = 0; iCent < fCentralityArrayBinsForCorrections-1; iCent++) {    
    //Printf("iCent %d:",iCent);    
    TString histoName = "fHistCorrectionPlus";
    histoName += Form("%d-%d",(Int_t)(fCentralityArrayForCorrections[iCent]),(Int_t)(fCentralityArrayForCorrections[iCent+1]));
    fHistCorrectionPlus[iCent]= dynamic_cast<TH3F *>(f->Get(histoName.Data()));
    if(!fHistCorrectionPlus[iCent]) {
      AliError(Form("fHist %s not found!!!",histoName.Data()));
      return;
    }
    
    histoName = "fHistCorrectionMinus";
    histoName += Form("%d-%d",(Int_t)(fCentralityArrayForCorrections[iCent]),(Int_t)(fCentralityArrayForCorrections[iCent+1]));
    fHistCorrectionMinus[iCent] = dynamic_cast<TH3F *>(f->Get(histoName.Data())); 
    if(!fHistCorrectionMinus[iCent]) {
      AliError(Form("fHist %s not found!!!",histoName.Data()));
      return; 
    }
  }//loop over centralities: ONLY the PbPb case is covered
}

//________________________________________________________________________
void AliAnalysisTaskBFPsi::UserExec(Option_t *) {
  // Main loop
  // Called for each event

  TString gAnalysisLevel = fBalance->GetAnalysisLevel();
  Int_t gNumberOfAcceptedTracks = 0;
  Double_t lMultiplicityVar     = -999.; //-1
  Double_t gReactionPlane       = -1.; 
  Float_t bSign = 0.;
  
  // get the event (for generator level: MCEvent())
  AliVEvent* eventMain = NULL;
  if(gAnalysisLevel == "MC") {
    eventMain = dynamic_cast<AliVEvent*>(MCEvent()); 
  }
  else{
    eventMain = dynamic_cast<AliVEvent*>(InputEvent());     
    // for HBT like cuts need magnetic field sign
    bSign = (eventMain->GetMagneticField() > 0) ? 1 : -1;
  }
  if(!eventMain) {
    AliError("eventMain not available");
    return;
  }
  
  // PID Response task active?
  if(fUsePID || fElectronRejection) {
    fPIDResponse = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->GetPIDResponse();
    if (!fPIDResponse) AliFatal("This Task needs the PID response attached to the inputHandler");
  }
 
  // check event cuts and fill event histograms
  if((lMultiplicityVar = IsEventAccepted(eventMain)) < 0){ 
    return;
  }
  // get the reaction plane
  if(fEventClass != "Multiplicity" && gAnalysisLevel!="AODnano") {
    gReactionPlane = GetEventPlane(eventMain);
    fHistEventPlane->Fill(gReactionPlane,lMultiplicityVar);
    if(gReactionPlane < 0){
      return;
    }
  }
  
  // get the accepted tracks in main event
  TObjArray *tracksMain = GetAcceptedTracks(eventMain,lMultiplicityVar,gReactionPlane);
  gNumberOfAcceptedTracks = tracksMain->GetEntriesFast();

  //multiplicity cut (used in pp)
  fHistNumberOfAcceptedTracks->Fill(gNumberOfAcceptedTracks,lMultiplicityVar);

  // store charges of all accepted tracks,shuffle and reassign(two extra loops)
  TObjArray* tracksShuffled = NULL;
  if(fRunShuffling){
    tracksShuffled = GetShuffledTracks(tracksMain,lMultiplicityVar);
  }
  
  // Event mixing 
  if (fRunMixing)
    {
      // 1. First get an event pool corresponding in mult (cent) and
      //    zvertex to the current event. Once initialized, the pool
      //    should contain nMix (reduced) events. This routine does not
      //    pre-scan the chain. The first several events of every chain
      //    will be skipped until the needed pools are filled to the
      //    specified depth. If the pool categories are not too rare, this
      //    should not be a problem. If they are rare, you could lose`
      //    statistics.
      
      // 2. Collect the whole pool's content of tracks into one TObjArray
      //    (bgTracks), which is effectively a single background super-event.
      
      // 3. The reduced and bgTracks arrays must both be passed into
      //    FillCorrelations(). Also nMix should be passed in, so a weight
      //    of 1./nMix can be applied.
      
      AliEventPool* pool = fPoolMgr->GetEventPool(lMultiplicityVar, eventMain->GetPrimaryVertex()->GetZ(),gReactionPlane);
      
      if (!pool){
	AliFatal(Form("No pool found for centrality = %f, zVtx = %f, psi = %f", lMultiplicityVar, eventMain->GetPrimaryVertex()->GetZ(),gReactionPlane));
      }
      else{
	
	//pool->SetDebug(1);

	if (pool->IsReady() || pool->NTracksInPool() > fMixingTracks / 10 || pool->GetCurrentNEvents() >= 5){ 
	  
	  
	  Int_t nMix = pool->GetCurrentNEvents();
	  //cout << "nMix = " << nMix << " tracks in pool = " << pool->NTracksInPool() << endl;
	  
	  //((TH1F*) fListOfHistos->FindObject("eventStat"))->Fill(2);
	  //((TH2F*) fListOfHistos->FindObject("mixedDist"))->Fill(centrality, pool->NTracksInPool());
	  //if (pool->IsReady())
	  //((TH1F*) fListOfHistos->FindObject("eventStat"))->Fill(3);
	  
	  // Fill mixed-event histos here  
	  for (Int_t jMix=0; jMix<nMix; jMix++) 
	    {
	      TObjArray* tracksMixed = pool->GetEvent(jMix);
	      fMixedBalance->CalculateBalance(gReactionPlane,tracksMain,tracksMixed,bSign,lMultiplicityVar,eventMain->GetPrimaryVertex()->GetZ());
	    }
	}
	
	// Update the Event pool
	pool->UpdatePool(tracksMain);
	//pool->PrintInfo();
	
      }//pool NULL check  
    }//run mixing
  
  // calculate balance function
  fBalance->CalculateBalance(gReactionPlane,tracksMain,NULL,bSign,lMultiplicityVar,eventMain->GetPrimaryVertex()->GetZ());
  
  // calculate shuffled balance function
  if(fRunShuffling && tracksShuffled != NULL) {
    fShuffledBalance->CalculateBalance(gReactionPlane,tracksShuffled,NULL,bSign,lMultiplicityVar,eventMain->GetPrimaryVertex()->GetZ());
  }
}      

//________________________________________________________________________
Double_t AliAnalysisTaskBFPsi::IsEventAccepted(AliVEvent *event){
  // Checks the Event cuts
  // Fills Event statistics histograms
  
  Bool_t isSelectedMain = kTRUE;
  Float_t gRefMultiplicity = -1.;
  TString gAnalysisLevel = fBalance->GetAnalysisLevel();

  AliMCEvent *mcevent = dynamic_cast<AliMCEvent*>(event);

  fHistEventStats->Fill(1,gRefMultiplicity); //all events

  // check first event in chunk (is not needed for new reconstructions)
  if(fCheckFirstEventInChunk){
    AliAnalysisUtils ut;
    if(ut.IsFirstEventInChunk(event)) 
      return -1.;
    fHistEventStats->Fill(6,gRefMultiplicity); 
  }
  // check for pile-up event
  if(fCheckPileUp){
    AliAnalysisUtils ut;
    ut.SetUseMVPlpSelection(kTRUE);
    ut.SetUseOutOfBunchPileUp(kTRUE);
    if(ut.IsPileUpEvent(event))
      return -1.;
    fHistEventStats->Fill(7,gRefMultiplicity); 
  }

  // Event trigger bits
  fHistTriggerStats->Fill(((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected());
  if(fUseOfflineTrigger)
    isSelectedMain = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
  
  if(isSelectedMain) {
    fHistEventStats->Fill(2,gRefMultiplicity); //triggered events
 
    // Event Vertex MC
    if(gAnalysisLevel == "MC") {
      if(!event) {
	AliError("mcEvent not available");
	return 0x0;
      }
      
      if(mcevent){
	AliGenEventHeader *header = dynamic_cast<AliGenEventHeader*>(mcevent->GenEventHeader());
	if(header){  
	  TArrayF gVertexArray;
	  header->PrimaryVertex(gVertexArray);
	  //Printf("Vertex: %lf (x) - %lf (y) - %lf (z)",
	  //gVertexArray.At(0),
	  //gVertexArray.At(1),
	  //gVertexArray.At(2));
	  fHistEventStats->Fill(3,gRefMultiplicity); //events with a proper vertex
	  if(TMath::Abs(gVertexArray.At(0)) < fVxMax) {
	    if(TMath::Abs(gVertexArray.At(1)) < fVyMax) {
	      if(TMath::Abs(gVertexArray.At(2)) < fVzMax) {
		fHistEventStats->Fill(4,gRefMultiplicity);//analyzed events

		// get the reference multiplicty or centrality
		gRefMultiplicity = GetRefMultiOrCentrality(event);

		fHistVx->Fill(gVertexArray.At(0));
		fHistVy->Fill(gVertexArray.At(1));
		fHistVz->Fill(gVertexArray.At(2),gRefMultiplicity);
		
		// take only events inside centrality class
		if(fUseCentrality) {
		  if((fImpactParameterMin < gRefMultiplicity) && (fImpactParameterMax > gRefMultiplicity)){
		    fHistEventStats->Fill(5,gRefMultiplicity); //events with correct centrality
		    return gRefMultiplicity;	    
		  }//centrality class
		}
		// take events only within the same multiplicity class
		else if(fUseMultiplicity) {
		  if((gRefMultiplicity > fNumberOfAcceptedTracksMin) && (gRefMultiplicity < fNumberOfAcceptedTracksMax)) {
		    fHistEventStats->Fill(5,gRefMultiplicity); //events with correct multiplicity
		    return gRefMultiplicity;
		  }
		}//multiplicity range
	      }//Vz cut
	    }//Vy cut
	  }//Vx cut
	}//header    
      }//MC event object
    }//MC
    
    // Event Vertex AOD, ESD, ESDMC
    else{
      const AliVVertex *vertex = event->GetPrimaryVertex();
      
      if(vertex) {
	Double32_t fCov[6];
	vertex->GetCovarianceMatrix(fCov);
	if(vertex->GetNContributors() > 0) {
	  if(fCov[5] != 0) {
	    fHistEventStats->Fill(3,gRefMultiplicity); //proper vertex
	    if(TMath::Abs(vertex->GetX()) < fVxMax) {
	      if(TMath::Abs(vertex->GetY()) < fVyMax) {
		if(TMath::Abs(vertex->GetZ()) < fVzMax) {
		  fHistEventStats->Fill(4,gRefMultiplicity);//analyzed events

		  // get the reference multiplicty or centrality
		  gRefMultiplicity = GetRefMultiOrCentrality(event);
		  
		  fHistVx->Fill(vertex->GetX());
		  fHistVy->Fill(vertex->GetY());
		  fHistVz->Fill(vertex->GetZ(),gRefMultiplicity);
		  
		  // take only events inside centrality class
		  if(fUseCentrality) {
		    if((gRefMultiplicity > fCentralityPercentileMin) && (gRefMultiplicity < fCentralityPercentileMax)){

		      // centrality weighting (optional for 2011 if central and semicentral triggers are used)
		      if (fCentralityWeights && !AcceptEventCentralityWeight(gRefMultiplicity)){
			AliInfo(Form("Rejecting event because of centrality weighting: %f", gRefMultiplicity));
			return -1;
		      }
		      
		      fHistEventStats->Fill(5,gRefMultiplicity); //events with correct centrality
		      return gRefMultiplicity;		
		    }//centrality class
		  }
		  // take events only within the same multiplicity class
		  else if(fUseMultiplicity) {
		    //if(fDebugLevel) 
		    //Printf("N(min): %.0f, N(max): %.0f - N(ref): %.0f",fNumberOfAcceptedTracksMin,
		    //fNumberOfAcceptedTracksMax,gRefMultiplicity);

		    if((gRefMultiplicity > fNumberOfAcceptedTracksMin) && (gRefMultiplicity < fNumberOfAcceptedTracksMax)) {
		      fHistEventStats->Fill(5,gRefMultiplicity); //events with correct multiplicity
		      return gRefMultiplicity;
		    }
		  }//multiplicity range
		}//Vz cut
	      }//Vy cut
	    }//Vx cut
	  }//proper vertex resolution
	}//proper number of contributors
      }//vertex object valid
    }//triggered event 
  }//AOD,ESD,ESDMC
  
  // in all other cases return -1 (event not accepted)
  return -1;
}


//________________________________________________________________________
Double_t AliAnalysisTaskBFPsi::GetRefMultiOrCentrality(AliVEvent *event){
    // Checks the Event cuts
    // Fills Event statistics histograms

  Float_t gCentrality = -1.;
  Double_t gMultiplicity = -1.;
  TString gAnalysisLevel = fBalance->GetAnalysisLevel();


  // calculate centrality always (not only in centrality mode)
  if(gAnalysisLevel == "AOD"|| gAnalysisLevel == "MCAOD" || gAnalysisLevel == "MCAODrec" ) { //centrality in AOD header  //++++++++++++++
    AliAODHeader *header = (AliAODHeader*) event->GetHeader();
    if(header){
      gCentrality = header->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());

      // QA for centrality estimators
      fHistCentStats->Fill(0.,header->GetCentralityP()->GetCentralityPercentile("V0M"));
      fHistCentStats->Fill(1.,header->GetCentralityP()->GetCentralityPercentile("V0A"));
      fHistCentStats->Fill(2.,header->GetCentralityP()->GetCentralityPercentile("V0C"));
      fHistCentStats->Fill(3.,header->GetCentralityP()->GetCentralityPercentile("FMD"));
      fHistCentStats->Fill(4.,header->GetCentralityP()->GetCentralityPercentile("TRK"));
      fHistCentStats->Fill(5.,header->GetCentralityP()->GetCentralityPercentile("TKL")); 
      fHistCentStats->Fill(6.,header->GetCentralityP()->GetCentralityPercentile("CL0"));
      fHistCentStats->Fill(7.,header->GetCentralityP()->GetCentralityPercentile("CL1"));
      fHistCentStats->Fill(8.,header->GetCentralityP()->GetCentralityPercentile("ZNA"));
      fHistCentStats->Fill(9.,header->GetCentralityP()->GetCentralityPercentile("ZPA"));
      fHistCentStats->Fill(10.,header->GetCentralityP()->GetCentralityPercentile("V0MvsFMD"));
      fHistCentStats->Fill(11.,header->GetCentralityP()->GetCentralityPercentile("TKLvsV0M"));
      fHistCentStats->Fill(12.,header->GetCentralityP()->GetCentralityPercentile("ZEMvsZDC"));
      
      // Centrality estimator USED   ++++++++++++++++++++++++++++++
      fHistCentStatsUsed->Fill(0.,header->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data()));
      
      // centrality QA (V0M)
      fHistV0M->Fill(event->GetVZEROData()->GetMTotV0A(), event->GetVZEROData()->GetMTotV0C());
      
      // centrality QA (reference tracks)
      fHistRefTracks->Fill(0.,header->GetRefMultiplicity());
      fHistRefTracks->Fill(1.,header->GetRefMultiplicityPos());
      fHistRefTracks->Fill(2.,header->GetRefMultiplicityNeg());
      fHistRefTracks->Fill(3.,header->GetTPConlyRefMultiplicity());
      fHistRefTracks->Fill(4.,header->GetNumberOfITSClusters(0));
      fHistRefTracks->Fill(5.,header->GetNumberOfITSClusters(1));
      fHistRefTracks->Fill(6.,header->GetNumberOfITSClusters(2));
      fHistRefTracks->Fill(7.,header->GetNumberOfITSClusters(3));
      fHistRefTracks->Fill(8.,header->GetNumberOfITSClusters(4));

    }//AOD header
  }//AOD

  // calculate centrality always (not only in centrality mode)
  else if(gAnalysisLevel == "AODnano" ) { //centrality via JF workaround
    
    AliAODHeader *header = (AliAODHeader*) event->GetHeader();
    if(header){
      gCentrality = (Float_t) gROOT->ProcessLine(Form("100.0 + 100.0 * ((AliNanoAODHeader*) %p)->GetCentrality(\"%s\")", header,fCentralityEstimator.Data())) / 100 - 1.0;
      
      // QA histogram
      fHistCentStatsUsed->Fill(0.,gCentrality);

    }//AOD header
  }//AODnano
  
  else if(gAnalysisLevel == "ESD" || gAnalysisLevel == "MCESD"){ // centrality class for ESDs or MC-ESDs
    AliCentrality *centrality = event->GetCentrality();
    gCentrality = centrality->GetCentralityPercentile(fCentralityEstimator.Data());

    // QA for centrality estimators
    fHistCentStats->Fill(0.,centrality->GetCentralityPercentile("V0M"));
    fHistCentStats->Fill(1.,centrality->GetCentralityPercentile("V0A"));
    fHistCentStats->Fill(2.,centrality->GetCentralityPercentile("V0C"));
    fHistCentStats->Fill(3.,centrality->GetCentralityPercentile("FMD"));
    fHistCentStats->Fill(4.,centrality->GetCentralityPercentile("TRK"));
    fHistCentStats->Fill(5.,centrality->GetCentralityPercentile("TKL"));
    fHistCentStats->Fill(6.,centrality->GetCentralityPercentile("CL0"));
    fHistCentStats->Fill(7.,centrality->GetCentralityPercentile("CL1"));
    fHistCentStats->Fill(8.,centrality->GetCentralityPercentile("ZNA"));
    fHistCentStats->Fill(9.,centrality->GetCentralityPercentile("ZPA"));
    fHistCentStats->Fill(10.,centrality->GetCentralityPercentile("V0MvsFMD"));
    fHistCentStats->Fill(11.,centrality->GetCentralityPercentile("TKLvsV0M"));
    fHistCentStats->Fill(12.,centrality->GetCentralityPercentile("ZEMvsZDC"));
    
    // Centrality estimator USED   ++++++++++++++++++++++++++++++
    fHistCentStatsUsed->Fill(0.,centrality->GetCentralityPercentile(fCentralityEstimator.Data()));
    
    // centrality QA (V0M)
    fHistV0M->Fill(event->GetVZEROData()->GetMTotV0A(), event->GetVZEROData()->GetMTotV0C());
  }//ESD

  else if(gAnalysisLevel == "MC"){
    Double_t gImpactParameter = 0.;
    AliMCEvent *gMCEvent = dynamic_cast<AliMCEvent*>(event);
    if(gMCEvent){
      AliCollisionGeometry* headerH = dynamic_cast<AliCollisionGeometry*>(gMCEvent->GenEventHeader());      
      if(headerH){
	gImpactParameter = headerH->ImpactParameter();
	gCentrality      = gImpactParameter;
      }//MC header
    }//MC event cast
  }//MC

  else{
    gCentrality = -1.;
  }
  
  // calculate reference multiplicity always (not only in multiplicity mode)
  if(gAnalysisLevel == "ESD" || gAnalysisLevel == "MCESD"){
    AliESDEvent* gESDEvent = dynamic_cast<AliESDEvent*>(event);
    if(gESDEvent){
      gMultiplicity = fESDtrackCuts->GetReferenceMultiplicity(gESDEvent, AliESDtrackCuts::kTrackletsITSTPC,0.5);
      fHistMultiplicity->Fill(gMultiplicity);
    }//AliESDevent cast
  }//ESD mode

  else if(gAnalysisLevel == "AOD"|| gAnalysisLevel == "MCAOD" || gAnalysisLevel == "MCAODrec" ){
    AliAODHeader *header = (AliAODHeader*) event->GetHeader();
    if ((fMultiplicityEstimator == "V0M")||
	(fMultiplicityEstimator == "V0A")||
	(fMultiplicityEstimator == "V0C") ||
	(fMultiplicityEstimator == "TPC")) {
      gMultiplicity = GetReferenceMultiplicityFromAOD(event);
      if(fDebugLevel) Printf("Reference multiplicity (calculated): %.0f",gMultiplicity);
    }
    else {
      if(header)
	gMultiplicity = header->GetRefMultiplicity();
      if(fDebugLevel) Printf("Reference multiplicity (AOD header): %.0f",gMultiplicity);
    }
    fHistMultiplicity->Fill(gMultiplicity);
  }//AOD mode
  else if(gAnalysisLevel == "MC") {
    AliMCEvent* gMCEvent = dynamic_cast<AliMCEvent*>(event);
    //Calculating the multiplicity as the number of charged primaries
    //within \pm 0.8 in eta and pT > 0.1 GeV/c
    for(Int_t iParticle = 0; iParticle < gMCEvent->GetNumberOfPrimaries(); iParticle++) {
      AliMCParticle* track = dynamic_cast<AliMCParticle *>(gMCEvent->GetTrack(iParticle));
      if (!track) {
	AliError(Form("Could not receive particle %d", iParticle));
	continue;
      }
      
      //exclude non stable particles
      if(!(gMCEvent->IsPhysicalPrimary(iParticle))) continue;
      
      //++++++++++++++++
      if (fMultiplicityEstimator == "V0M") {
	if((track->Eta() > 5.1 || track->Eta() < 2.8)&&(track->Eta() < -3.7 || track->Eta() > -1.7)) 
	  continue;}
      else if (fMultiplicityEstimator == "V0A") {
	if(track->Eta() > 5.1 || track->Eta() < 2.8)  continue;}
      else if (fMultiplicityEstimator == "V0C") {
	if(track->Eta() > -1.7 || track->Eta() < -3.7)  continue;}
      else if (fMultiplicityEstimator == "TPC") {
	if(track->Eta() < fEtaMin || track->Eta() > fEtaMax)  continue;
	if(track->Pt() < fPtMin || track->Pt() > fPtMax)  continue;
      }
      else{
	if(track->Pt() < fPtMin || track->Pt() > fPtMax)  continue;
	if(track->Eta() < fEtaMin || track->Eta() > fEtaMax)  continue;
      }
      //++++++++++++++++
      
      if(track->Charge() == 0) continue;
      
      gMultiplicity += 1;
    }//loop over primaries
    fHistMultiplicity->Fill(gMultiplicity);
  }//MC mode
  else{
    gMultiplicity = -1;
  }
  

  // decide what should be returned only here
  Double_t lReturnVal = -100;
  if(fEventClass=="Multiplicity"){
    lReturnVal = gMultiplicity;
  }else if(fEventClass=="Centrality"){
    lReturnVal = gCentrality;
  }
  return lReturnVal;
}

//________________________________________________________________________
Double_t AliAnalysisTaskBFPsi::GetReferenceMultiplicityFromAOD(AliVEvent *event){
  //Function that returns the reference multiplicity from AODs (data or reco MC)
  //Different ref. mult. implemented: V0M, V0A, V0C, TPC
  Double_t gRefMultiplicity = 0., gRefMultiplicityTPC = 0.;
  Double_t gRefMultiplicityVZERO = 0., gRefMultiplicityVZEROA = 0., gRefMultiplicityVZEROC = 0.;

  AliAODHeader *header = dynamic_cast<AliAODHeader *>(event->GetHeader());
  if(!header) {
    Printf("ERROR: AOD header not available");
    return -999;
  }
  Int_t gRunNumber = header->GetRunNumber();

  // Loop over tracks in event
  for (Int_t iTracks = 0; iTracks < event->GetNumberOfTracks(); iTracks++) {
    AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(event->GetTrack(iTracks));
    if (!aodTrack) {
      AliError(Form("Could not receive track %d", iTracks));
      continue;
    }
    
    // AOD track cuts
    if(!aodTrack->TestFilterBit(fnAODtrackCutBit)) continue;
            
    if(aodTrack->Charge() == 0) continue;
    // Kinematics cuts from ESD track cuts
    if( aodTrack->Pt() < fPtMin || aodTrack->Pt() > fPtMax)      continue;
    if( aodTrack->Eta() < fEtaMin || aodTrack->Eta() > fEtaMax)  continue;
    
    //=================PID (so far only for electron rejection)==========================//
    if(fElectronRejection) {
      // get the electron nsigma
      Double_t nSigma = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kElectron));
      
      // check only for given momentum range
      if( aodTrack->Pt() > fElectronRejectionMinPt && aodTrack->Pt() < fElectronRejectionMaxPt ){
	//look only at electron nsigma
	if(!fElectronOnlyRejection) {
	  //Make the decision based on the n-sigma of electrons
	  if(nSigma < fElectronRejectionNSigma) continue;
	}
	else {
	  Double_t nSigmaPions   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kPion));
	  Double_t nSigmaKaons   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kKaon));
	  Double_t nSigmaProtons = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kProton));
	  
	  //Make the decision based on the n-sigma of electrons exclusively ( = track not in nsigma region for other species)
	  if(nSigma < fElectronRejectionNSigma
	     && nSigmaPions   > fElectronRejectionNSigma
	     && nSigmaKaons   > fElectronRejectionNSigma
	     && nSigmaProtons > fElectronRejectionNSigma ) continue;
	}
      }
    }//electron rejection
    
    gRefMultiplicityTPC += 1.0;
  }// track loop
  
  //VZERO segmentation in two detectors (0-31: VZERO-C, 32-63: VZERO-A)
  for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
    fHistVZEROSignal->Fill(iChannel,event->GetVZEROEqMultiplicity(iChannel));
    
    if(iChannel < 32) 
      gRefMultiplicityVZEROC += event->GetVZEROEqMultiplicity(iChannel);
    else if(iChannel >= 32) 
      gRefMultiplicityVZEROA += event->GetVZEROEqMultiplicity(iChannel);
  }//loop over PMTs
  
  //Equalization of gain
  Double_t gFactorA = GetEqualizationFactor(gRunNumber,"A");
  if(gFactorA != 0)
    gRefMultiplicityVZEROA /= gFactorA;
  Double_t gFactorC = GetEqualizationFactor(gRunNumber,"C");
  if(gFactorC != 0)
    gRefMultiplicityVZEROC /= gFactorC;
  if((gFactorA != 0)&&(gFactorC != 0)) 
    gRefMultiplicityVZERO = (gRefMultiplicityVZEROA/gFactorA)+(gRefMultiplicityVZEROC/gFactorC);
  
  if(fDebugLevel) 
    Printf("VZERO multiplicity: %.0f - TPC multiplicity: %.0f",gRefMultiplicityVZERO,gRefMultiplicityTPC);

  fHistTPCvsVZEROMultiplicity->Fill(gRefMultiplicityVZERO,gRefMultiplicityTPC);

  if(fMultiplicityEstimator == "TPC") 
    gRefMultiplicity = gRefMultiplicityTPC;
  else if(fMultiplicityEstimator == "V0M")
    gRefMultiplicity = gRefMultiplicityVZERO;
  else if(fMultiplicityEstimator == "V0A")
    gRefMultiplicity = gRefMultiplicityVZEROA;
  else if(fMultiplicityEstimator == "V0C")
    gRefMultiplicity = gRefMultiplicityVZEROC;
  
  return gRefMultiplicity;
}

//________________________________________________________________________
Double_t AliAnalysisTaskBFPsi::GetEventPlane(AliVEvent *event){
  // Get the event plane

  TString gAnalysisLevel = fBalance->GetAnalysisLevel();

  Float_t gVZEROEventPlane    = -10.;
  Float_t gReactionPlane      = -10.;
  Double_t qxTot = 0.0, qyTot = 0.0;

  //MC: from reaction plane
  if(gAnalysisLevel == "MC"){
    if(!event) {
      AliError("mcEvent not available");
      return 0x0;
    }

    AliMCEvent *gMCEvent = dynamic_cast<AliMCEvent*>(event);
    if(gMCEvent){
      AliCollisionGeometry* headerH = dynamic_cast<AliCollisionGeometry*>(gMCEvent->GenEventHeader());    
      if (headerH) {
	gReactionPlane = headerH->ReactionPlaneAngle();
	//gReactionPlane *= TMath::RadToDeg();
      }//MC header
    }//MC event cast
  }//MC
  
  // AOD,ESD,ESDMC: from VZERO Event Plane
  else{
   
    AliEventplane *ep = event->GetEventplane();
    if(ep){ 
      gVZEROEventPlane = ep->CalculateVZEROEventPlane(event,10,2,qxTot,qyTot);
      if(gVZEROEventPlane < 0.) gVZEROEventPlane += TMath::Pi();
      //gReactionPlane = gVZEROEventPlane*TMath::RadToDeg();
      gReactionPlane = gVZEROEventPlane;
    }
  }//AOD,ESD,ESDMC

  return gReactionPlane;
}

//________________________________________________________________________
Double_t AliAnalysisTaskBFPsi::GetTrackbyTrackCorrectionMatrix( Double_t vEta, 
								Double_t vPhi, 
								Double_t vPt, 
								Short_t vCharge, 
								Double_t gCentrality) {
  // -- Get efficiency correction of particle dependent on (eta, phi, pt, charge, centrality) 

  Double_t correction = 1.;
  Int_t gCentralityInt = -1;

  for (Int_t i=0; i<fCentralityArrayBinsForCorrections-1; i++){
    if((fCentralityArrayForCorrections[i] <= gCentrality)&&(gCentrality <= fCentralityArrayForCorrections[i+1])){
      gCentralityInt = i;
      break;
    }
  }  

  // centrality not in array --> no correction
  if(gCentralityInt < 0){
    correction = 1.;
  }
  else{
    
    //Printf("//=============CENTRALITY=============// %d:",gCentralityInt);
    
    if(fHistCorrectionPlus[gCentralityInt]){
      if (vCharge > 0) {
	correction = fHistCorrectionPlus[gCentralityInt]->GetBinContent(fHistCorrectionPlus[gCentralityInt]->FindBin(vEta,vPt,vPhi));
	//Printf("CORRECTIONplus: %.2f | Centrality %d",correction,gCentralityInt);  
      }
      if (vCharge < 0) {
	correction = fHistCorrectionPlus[gCentralityInt]->GetBinContent(fHistCorrectionMinus[gCentralityInt]->FindBin(vEta,vPt,vPhi));
	//Printf("CORRECTIONminus: %.2f | Centrality %d",correction,gCentralityInt); 
      }
    }
    else {
      correction = 1.;
    }
  }//centrality in array
  
  if (correction == 0.) { 
    AliError(Form("Should not happen : bin content = 0. >> eta: %.2f | phi : %.2f | pt : %.2f | cent %d",vEta, vPhi, vPt, gCentralityInt)); 
    correction = 1.; 
  } 
  
  return correction;
}

//________________________________________________________________________
TObjArray* AliAnalysisTaskBFPsi::GetAcceptedTracks(AliVEvent *event, Double_t gCentrality, Double_t gReactionPlane){
  // Returns TObjArray with tracks after all track cuts (only for AOD!)
  // Fills QA histograms

  TString gAnalysisLevel = fBalance->GetAnalysisLevel();

  //output TObjArray holding all good tracks
  TObjArray* tracksAccepted = new TObjArray;
  tracksAccepted->SetOwner(kTRUE);

  Short_t vCharge;
  Double_t vEta;
  Double_t vY;
  Double_t vPhi;
  Double_t vPt;


  if(gAnalysisLevel == "AOD") { // handling of TPC only tracks different in AOD and ESD
    // Loop over tracks in event
    
    for (Int_t iTracks = 0; iTracks < event->GetNumberOfTracks(); iTracks++) {
      AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(event->GetTrack(iTracks));
      if (!aodTrack) {
	AliError(Form("Could not receive track %d", iTracks));
	continue;
      }
      
      // AOD track cuts
      
      // For ESD Filter Information: ANALYSIS/macros/AddTaskESDfilter.C
      // take only TPC only tracks 
      //fHistTrackStats->Fill(aodTrack->GetFilterMap());
      for(Int_t iTrackBit = 0; iTrackBit < 16; iTrackBit++){
	fHistTrackStats->Fill(iTrackBit,aodTrack->TestFilterBit(1<<iTrackBit));
      }

      if(!aodTrack->TestFilterBit(fnAODtrackCutBit)) continue;


      // additional check on kPrimary flag
      if(fCheckPrimaryFlagAOD){
	if(aodTrack->GetType() != AliAODTrack::kPrimary)
	  continue;
      }

     
      vCharge = aodTrack->Charge();
      vEta    = aodTrack->Eta();
      vY      = aodTrack->Y();
      vPhi    = aodTrack->Phi();// * TMath::RadToDeg();
      vPt     = aodTrack->Pt();
      
      //===========================PID (so far only for electron rejection)===============================//		    
      if(fElectronRejection) {

	// get the electron nsigma
	Double_t nSigma = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kElectron));
	
	//Fill QA before the PID
	fHistdEdxVsPTPCbeforePIDelectron -> Fill(aodTrack->P()*aodTrack->Charge(),aodTrack->GetTPCsignal());
	fHistNSigmaTPCvsPtbeforePIDelectron -> Fill(aodTrack->P()*aodTrack->Charge(),nSigma); 
	//end of QA-before pid
	
	// check only for given momentum range
	if( vPt > fElectronRejectionMinPt && vPt < fElectronRejectionMaxPt ){
	  	  
	  //look only at electron nsigma
	  if(!fElectronOnlyRejection){
	    
	    //Make the decision based on the n-sigma of electrons
	    if(nSigma < fElectronRejectionNSigma) continue;
	  }
	  else{
	    
	    Double_t nSigmaPions   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kPion));
	    Double_t nSigmaKaons   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kKaon));
	    Double_t nSigmaProtons = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kProton));
	    
	    //Make the decision based on the n-sigma of electrons exclusively ( = track not in nsigma region for other species)
	    if(nSigma < fElectronRejectionNSigma
	       && nSigmaPions   > fElectronRejectionNSigma
	       && nSigmaKaons   > fElectronRejectionNSigma
	       && nSigmaProtons > fElectronRejectionNSigma ) continue;
	  }
	}
  
	//Fill QA after the PID
	fHistdEdxVsPTPCafterPIDelectron -> Fill(aodTrack->P()*aodTrack->Charge(),aodTrack->GetTPCsignal());
	fHistNSigmaTPCvsPtafterPIDelectron -> Fill(aodTrack->P()*aodTrack->Charge(),nSigma); 
	
      }
      //===========================end of PID (so far only for electron rejection)===============================//

      //+++++++++++++++++++++++++++++//
      //===========================PID===============================//		    
      if(fUsePID) {
	Double_t prob[AliPID::kSPECIES]={0.};
	Double_t probTPC[AliPID::kSPECIES]={0.};
	Double_t probTOF[AliPID::kSPECIES]={0.};
	Double_t probTPCTOF[AliPID::kSPECIES]={0.};
	
	Double_t nSigma = 0.;
	Double_t nSigmaTPC = 0.;
	Double_t nSigmaTOF = 0.; 
	Double_t nSigmaTPCTOF = 0.;
	UInt_t detUsedTPC = 0;
	UInt_t detUsedTOF = 0;
	UInt_t detUsedTPCTOF = 0;
	
	nSigmaTPC = fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)fParticleOfInterest);
	nSigmaTOF = fPIDResponse->NumberOfSigmasTOF(aodTrack,(AliPID::EParticleType)fParticleOfInterest);
	nSigmaTPCTOF = TMath::Sqrt(nSigmaTPC*nSigmaTPC + nSigmaTOF*nSigmaTOF);
	if (nSigmaTOF == 999 ||  nSigmaTOF == -999){
	  nSigmaTPCTOF = nSigmaTPC;
	}

	//Decide what detector configuration we want to use
	switch(fPidDetectorConfig) {
	case kTPCpid:
	  fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC);
	  nSigma = nSigmaTPC;
	  detUsedTPC = fPIDCombined->ComputeProbabilities(aodTrack, fPIDResponse, probTPC);
	  for(Int_t iSpecies = 0; iSpecies < AliPID::kSPECIES; iSpecies++)
	    prob[iSpecies] = probTPC[iSpecies];
	  break;
	case kTOFpid:
	  fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF);
	  nSigma = nSigmaTOF;
	  detUsedTOF = fPIDCombined->ComputeProbabilities(aodTrack, fPIDResponse, probTOF);
	  for(Int_t iSpecies = 0; iSpecies < AliPID::kSPECIES; iSpecies++)
	    prob[iSpecies] = probTOF[iSpecies];
	  break;
	case kTPCTOF:
	  fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF|AliPIDResponse::kDetTPC);
	  nSigma = nSigmaTPCTOF;
	  detUsedTPCTOF = fPIDCombined->ComputeProbabilities(aodTrack, fPIDResponse, probTPCTOF);
	  for(Int_t iSpecies = 0; iSpecies < AliPID::kSPECIES; iSpecies++)
	    prob[iSpecies] = probTPCTOF[iSpecies];
	  break;
	default:
	  break;
	}//end switch: define detector mask
	
	//Filling the PID QA
	Double_t tofTime = -999., length = 999., tof = -999.;
	Double_t c = TMath::C()*1.E-9;// m/ns
	Double_t beta = -999.;

	Float_t probMis = fPIDResponse->GetTOFMismatchProbability(aodTrack);
	if (probMis < 0.01) { //if u want to reduce mismatch using also TPC

	  if ((aodTrack->IsOn(AliAODTrack::kITSin)) &&  (aodTrack->IsOn(AliAODTrack::kTOFpid)) ) { //leonardo's analysis
	    
	    tofTime = aodTrack->GetTOFsignal();//in ps
	    length = aodTrack->GetIntegratedLength();
	    tof = tofTime*1E-3; // ns		      
	    if (tof <= 0) {
	      //Printf("WARNING: track with negative TOF time found! Skipping this track for PID checks\n");
	      continue;
	    }
	    if (length <= 0){
	      //printf("WARNING: track with negative length found!Skipping this track for PID checks\n");
	      continue;
	    }	      
	    length = length*0.01; // in meters
	    tof = tof*c;
	    beta = length/tof;
	    
	    fHistBetavsPTOFbeforePID ->Fill(aodTrack->P()*aodTrack->Charge(),beta);
	    fHistProbTOFvsPtbeforePID ->Fill(aodTrack->Pt(),probTOF[fParticleOfInterest]);
	    fHistNSigmaTOFvsPtbeforePID ->Fill(aodTrack->Pt(),nSigmaTOF);
	  }//TOF signal 
	  
	  fHistdEdxVsPTPCbeforePID -> Fill(aodTrack->GetTPCmomentum()*aodTrack->Charge(),aodTrack->GetTPCsignal()); //aodTrack->P()*aodTrack->Charge()
	  fHistProbTPCvsPtbeforePID -> Fill(aodTrack->Pt(),probTPC[fParticleOfInterest]); 
	  fHistNSigmaTPCvsPtbeforePID -> Fill(aodTrack->Pt(),nSigmaTPC);	
	  fHistProbTPCTOFvsPtbeforePID -> Fill(aodTrack->Pt(),probTPCTOF[fParticleOfInterest]);
	  
	  //combined TPC&TOF
	  fHistBetaVsdEdXbeforePID->Fill(aodTrack->GetTPCsignal(),beta); 	
	  fHistNSigmaTPCTOFvsPtbeforePID -> Fill(aodTrack->Pt(),nSigmaTPCTOF);
	  fHistNSigmaTPCTOFPbefPID ->Fill(nSigmaTPC,nSigmaTOF,aodTrack->P()); //++++++++++++++
	  //Printf("NSIGMA: %lf - nSigmaTOF: %lf - nSigmaTPC: %lf - nSigmaTPCTOF: %lf",nSigma,nSigmaTOF,nSigmaTPC,nSigmaTPCTOF); 
	  //end of QA-before pid
	  
	  if ((detUsedTPC != 0)||(detUsedTOF != 0)||(detUsedTPCTOF != 0)) {
	    //Make the decision based on the n-sigma
	    if(fUsePIDnSigma) {
	      if(nSigma > fPIDNSigma || nSigma < -fPIDNSigma) continue;  
	      
	      fHistNSigmaTOFvsPtafterPID ->Fill(aodTrack->Pt(),nSigmaTOF);
	      fHistNSigmaTPCvsPtafterPID ->Fill(aodTrack->Pt(),nSigmaTPC);
	      fHistNSigmaTPCTOFvsPtafterPID ->Fill(aodTrack->Pt(),nSigmaTPCTOF);
	      fHistNSigmaTPCTOFPafterPID ->Fill(nSigmaTPC,nSigmaTOF,aodTrack->P());  //++++++++++++++
	    }
	    //Make the decision based on the bayesian
	    else if(fUsePIDPropabilities) {
	      if(fParticleOfInterest != TMath::LocMax(AliPID::kSPECIES,prob)) continue;
	      if (prob[fParticleOfInterest] < fMinAcceptedPIDProbability) continue;      
	      
	      fHistProbTOFvsPtafterPID ->Fill(aodTrack->Pt(),probTOF[fParticleOfInterest]);
	      fHistProbTPCvsPtafterPID ->Fill(aodTrack->Pt(),probTPC[fParticleOfInterest]); 
	      fHistProbTPCTOFvsPtafterPID ->Fill(aodTrack->Pt(),probTPCTOF[fParticleOfInterest]);
	    }	   
	    
	    //Fill QA after the PID
	    fHistBetavsPTOFafterPID ->Fill(aodTrack->P()*aodTrack->Charge(),beta);
	    fHistdEdxVsPTPCafterPID ->Fill(aodTrack->P()*aodTrack->Charge(),aodTrack->GetTPCsignal());
	    fHistBetaVsdEdXafterPID ->Fill(aodTrack->GetTPCsignal(),beta);
	  }
	}
      }
      //===========================PID===============================//
      //+++++++++++++++++++++++++++++//


      Float_t dcaXY = aodTrack->DCA();      // this is the DCA from global track (not exactly what is cut on)
      Float_t dcaZ  = aodTrack->ZAtDCA();   // this is the DCA from global track (not exactly what is cut on)
      
      
      // Kinematics cuts from ESD track cuts
      if( vPt < fPtMin || vPt > fPtMax)      continue;
      if( vEta < fEtaMin || vEta > fEtaMax)  continue;
      
      // Extra DCA cuts (for systematic studies [!= -1])
      if( fDCAxyCut != -1 && fDCAzCut != -1){
	if(TMath::Sqrt((dcaXY*dcaXY)/(fDCAxyCut*fDCAxyCut)+(dcaZ*dcaZ)/(fDCAzCut*fDCAzCut)) > 1 ){
	  continue;  // 2D cut
	}
      }
      
      // Extra TPC cuts (for systematic studies [!= -1])
      if( fTPCchi2Cut != -1 && aodTrack->Chi2perNDF() > fTPCchi2Cut){
	continue;
      }
      if( fNClustersTPCCut != -1 && aodTrack->GetTPCNcls() < fNClustersTPCCut){
	continue;
      }

      // Extra cut on shared clusters
      if( fTPCsharedCut != -1 && aodTrack->GetTPCnclsS() > fTPCsharedCut){
	continue;
      }
      
      // fill QA histograms
      fHistClus->Fill(aodTrack->GetITSNcls(),aodTrack->GetTPCNcls());
      fHistDCA->Fill(dcaZ,dcaXY);
      fHistChi2->Fill(aodTrack->Chi2perNDF(),gCentrality);
      fHistPt->Fill(vPt,gCentrality);
      fHistEta->Fill(vEta,gCentrality);
      fHistRapidity->Fill(vY,gCentrality);
      if(vCharge > 0) fHistPhiPos->Fill(vPhi,gCentrality);
      else if(vCharge < 0) fHistPhiNeg->Fill(vPhi,gCentrality);
      fHistPhi->Fill(vPhi,gCentrality);
      if(vCharge > 0)      fHistEtaPhiPos->Fill(vEta,vPhi,gCentrality); 		 
      else if(vCharge < 0) fHistEtaPhiNeg->Fill(vEta,vPhi,gCentrality);
      
      //=======================================correction
      Double_t correction = GetTrackbyTrackCorrectionMatrix(vEta, vPhi, vPt, vCharge, gCentrality);  
      //Printf("CORRECTIONminus: %.2f | Centrality %lf",correction,gCentrality);
      
      // add the track to the TObjArray
      tracksAccepted->Add(new AliBFBasicParticle(vEta, vPhi, vPt, vCharge, correction));  
    }//track loop
  }// AOD analysis


  // nano AODs
  else if(gAnalysisLevel == "AODnano") { // not fully supported yet (PID missing)
    // Loop over tracks in event
    
    for (Int_t iTracks = 0; iTracks < event->GetNumberOfTracks(); iTracks++) {
      AliVTrack* aodTrack = dynamic_cast<AliVTrack *>(event->GetTrack(iTracks));
      if (!aodTrack) {
	AliError(Form("Could not receive track %d", iTracks));
	continue;
      }
      
      // AOD track cuts (not needed)
      //if(!aodTrack->TestFilterBit(fnAODtrackCutBit)) continue;
     
      vCharge = aodTrack->Charge();
      vEta    = aodTrack->Eta();
      vY      = -999.;
      vPhi    = aodTrack->Phi();// * TMath::RadToDeg();
      vPt     = aodTrack->Pt();
           
      
      // Kinematics cuts from ESD track cuts
      if( vPt < fPtMin || vPt > fPtMax)      continue;
      if( vEta < fEtaMin || vEta > fEtaMax)  continue;
      
       
      // fill QA histograms
      fHistPt->Fill(vPt,gCentrality);
      fHistEta->Fill(vEta,gCentrality);
      fHistRapidity->Fill(vY,gCentrality);
      if(vCharge > 0) fHistPhiPos->Fill(vPhi,gCentrality);
      else if(vCharge < 0) fHistPhiNeg->Fill(vPhi,gCentrality);
      fHistPhi->Fill(vPhi,gCentrality);
      if(vCharge > 0)      fHistEtaPhiPos->Fill(vEta,vPhi,gCentrality); 		 
      else if(vCharge < 0) fHistEtaPhiNeg->Fill(vEta,vPhi,gCentrality);
      
      //=======================================correction
      Double_t correction = GetTrackbyTrackCorrectionMatrix(vEta, vPhi, vPt, vCharge, gCentrality);  
      //Printf("CORRECTIONminus: %.2f | Centrality %lf",correction,gCentrality);
      
      // add the track to the TObjArray
      tracksAccepted->Add(new AliBFBasicParticle(vEta, vPhi, vPt, vCharge, correction));  
    }//track loop
  }// AOD nano analysis


  //==============================================================================================================
  else if(gAnalysisLevel == "MCAOD") {
    
    AliMCEvent* mcEvent = MCEvent();
    if (!mcEvent) {
      AliError("ERROR: Could not retrieve MC event");
    }
    else{
      
      for (Int_t iTracks = 0; iTracks < mcEvent->GetNumberOfTracks(); iTracks++) {
	AliAODMCParticle *aodTrack = (AliAODMCParticle*) mcEvent->GetTrack(iTracks); 
	if (!aodTrack) {
	  AliError(Form("ERROR: Could not receive track %d (mc loop)", iTracks));
	  continue;
	}
	
	if(!aodTrack->IsPhysicalPrimary()) continue;   
	
	vCharge = aodTrack->Charge();
	vEta    = aodTrack->Eta();
	vY      = aodTrack->Y();
	vPhi    = aodTrack->Phi();// * TMath::RadToDeg();
	vPt     = aodTrack->Pt();
	
	// Kinematics cuts from ESD track cuts
	if( vPt < fPtMin || vPt > fPtMax)      continue;
	if( vEta < fEtaMin || vEta > fEtaMax)  continue;
	
	// Remove neutral tracks
	if( vCharge == 0 ) continue;
	
	//Exclude resonances
	if(fExcludeResonancesInMC) {
	  
	  Bool_t kExcludeParticle = kFALSE;
	  Int_t gMotherIndex = aodTrack->GetMother();
	  if(gMotherIndex != -1) {
	    AliAODMCParticle* motherTrack = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(gMotherIndex));
	    if(motherTrack) {
	      Int_t pdgCodeOfMother = motherTrack->GetPdgCode();
	      //if((pdgCodeOfMother == 113)||(pdgCodeOfMother == 213)||(pdgCodeOfMother == 221)||(pdgCodeOfMother == 223)||(pdgCodeOfMother == 331)||(pdgCodeOfMother == 333)) {
	      //if(pdgCodeOfMother == 113) {
	      if(pdgCodeOfMother == 113  // rho0
		 || pdgCodeOfMother == 213 || pdgCodeOfMother == -213 // rho+
		 // || pdgCodeOfMother == 221  // eta
		 // || pdgCodeOfMother == 331  // eta'
		 // || pdgCodeOfMother == 223  // omega
		 // || pdgCodeOfMother == 333  // phi
		 || pdgCodeOfMother == 311  || pdgCodeOfMother == -311 // K0
		 // || pdgCodeOfMother == 313  || pdgCodeOfMother == -313 // K0*
		 // || pdgCodeOfMother == 323  || pdgCodeOfMother == -323 // K+*
		 || pdgCodeOfMother == 3122 || pdgCodeOfMother == -3122 // Lambda
		 || pdgCodeOfMother == 111  // pi0 Dalitz
		 || pdgCodeOfMother == 22  // photon
		 ) {
		kExcludeParticle = kTRUE;
	      }
	    }
	  }
	  
	  //Exclude from the analysis decay products of rho0, rho+, eta, eta' and phi
	  if(kExcludeParticle) continue;
	}

	//Exclude electrons with PDG
	if(fExcludeElectronsInMC) {
	  
	  if(TMath::Abs(aodTrack->GetPdgCode()) == 11) continue;
	  
	}
	
	// fill QA histograms
	fHistPt->Fill(vPt,gCentrality);
	fHistEta->Fill(vEta,gCentrality);
	fHistRapidity->Fill(vY,gCentrality);
	if(vCharge > 0) fHistPhiPos->Fill(vPhi,gCentrality);
	else if(vCharge < 0) fHistPhiNeg->Fill(vPhi,gCentrality);
	fHistPhi->Fill(vPhi,gCentrality);
	if(vCharge > 0)      fHistEtaPhiPos->Fill(vEta,vPhi,gCentrality); 		 
	else if(vCharge < 0) fHistEtaPhiNeg->Fill(vEta,vPhi,gCentrality);
	
	//=======================================correction
	Double_t correction = GetTrackbyTrackCorrectionMatrix(vEta, vPhi, vPt, vCharge, gCentrality);  
	//Printf("CORRECTIONminus: %.2f | Centrality %lf",correction,gCentrality);   
	
	// add the track to the TObjArray
	tracksAccepted->Add(new AliBFBasicParticle(vEta, vPhi, vPt, vCharge, correction));  
      }//aodTracks
    }//MC event
  }//MCAOD
  //==============================================================================================================

  //==============================================================================================================
  else if(gAnalysisLevel == "MCAODrec") {
    
    /* fAOD = dynamic_cast<AliAODEvent*>(InputEvent());
    if (!fAOD) {
      printf("ERROR: fAOD not available\n");
      return;
      }*/
    
    fArrayMC = dynamic_cast<TClonesArray*>(event->FindListObject(AliAODMCParticle::StdBranchName())); 
    if (!fArrayMC) { 
       AliError("No array of MC particles found !!!");
    }

    AliMCEvent* mcEvent = MCEvent();
    if (!mcEvent) {
       AliError("ERROR: Could not retrieve MC event");
       return tracksAccepted;
    }
     
    for (Int_t iTracks = 0; iTracks < event->GetNumberOfTracks(); iTracks++) {
      AliAODTrack* aodTrack = dynamic_cast<AliAODTrack *>(event->GetTrack(iTracks));
      if (!aodTrack) {
	AliError(Form("Could not receive track %d", iTracks));
	continue;
      }
      
      for(Int_t iTrackBit = 0; iTrackBit < 16; iTrackBit++){
	fHistTrackStats->Fill(iTrackBit,aodTrack->TestFilterBit(1<<iTrackBit));
      }
      if(!aodTrack->TestFilterBit(fnAODtrackCutBit)) continue;
      
      vCharge = aodTrack->Charge();
      vEta    = aodTrack->Eta();
      vY      = aodTrack->Y();
      vPhi    = aodTrack->Phi();// * TMath::RadToDeg();
      vPt     = aodTrack->Pt();
      
      //===========================use MC information for Kinematics===============================//		    
      if(fUseMCforKinematics){

	Int_t label = TMath::Abs(aodTrack->GetLabel());
	AliAODMCParticle *AODmcTrack = (AliAODMCParticle*) fArrayMC->At(label);

	if(AODmcTrack){
	  vCharge = AODmcTrack->Charge();
	  vEta    = AODmcTrack->Eta();
	  vY      = AODmcTrack->Y();
	  vPhi    = AODmcTrack->Phi();// * TMath::RadToDeg();
	  vPt     = AODmcTrack->Pt();
	}
	else{
	  AliDebug(1, "no MC particle for this track"); 
	  continue;
	}
      }
      //===========================end of use MC information for Kinematics========================//		    


      //===========================PID (so far only for electron rejection)===============================//		    
      if(fElectronRejection) {

	// get the electron nsigma
	Double_t nSigma = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kElectron));

	//Fill QA before the PID
	fHistdEdxVsPTPCbeforePIDelectron -> Fill(aodTrack->P()*aodTrack->Charge(),aodTrack->GetTPCsignal());
	fHistNSigmaTPCvsPtbeforePIDelectron -> Fill(aodTrack->P()*aodTrack->Charge(),nSigma); 
	//end of QA-before pid
	
	// check only for given momentum range
	if( vPt > fElectronRejectionMinPt && vPt < fElectronRejectionMaxPt ){
	  	  
	  //look only at electron nsigma
	  if(!fElectronOnlyRejection){
	    
	    //Make the decision based on the n-sigma of electrons
	    if(nSigma < fElectronRejectionNSigma) continue;
	  }
	  else{
	    
	    Double_t nSigmaPions   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kPion));
	    Double_t nSigmaKaons   = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kKaon));
	    Double_t nSigmaProtons = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(aodTrack,(AliPID::EParticleType)AliPID::kProton));
	    
	    //Make the decision based on the n-sigma of electrons exclusively ( = track not in nsigma region for other species)
	    if(nSigma < fElectronRejectionNSigma
	       && nSigmaPions   > fElectronRejectionNSigma
	       && nSigmaKaons   > fElectronRejectionNSigma
	       && nSigmaProtons > fElectronRejectionNSigma ) continue;
	  }
	}
  
	//Fill QA after the PID
	fHistdEdxVsPTPCafterPIDelectron -> Fill(aodTrack->P()*aodTrack->Charge(),aodTrack->GetTPCsignal());
	fHistNSigmaTPCvsPtafterPIDelectron -> Fill(aodTrack->P()*aodTrack->Charge(),nSigma); 
	
      }
      //===========================end of PID (so far only for electron rejection)===============================//
      
      Float_t dcaXY = aodTrack->DCA();      // this is the DCA from global track (not exactly what is cut on)
      Float_t dcaZ  = aodTrack->ZAtDCA();   // this is the DCA from global track (not exactly what is cut on)
            
      // Kinematics cuts from ESD track cuts
      if( vPt < fPtMin || vPt > fPtMax)      continue;
      if( vEta < fEtaMin || vEta > fEtaMax)  continue;
      
      // Extra DCA cuts (for systematic studies [!= -1])
      if( fDCAxyCut != -1 && fDCAzCut != -1){
	if(TMath::Sqrt((dcaXY*dcaXY)/(fDCAxyCut*fDCAxyCut)+(dcaZ*dcaZ)/(fDCAzCut*fDCAzCut)) > 1 ){
	  continue;  // 2D cut
	}
      }
      
      // Extra TPC cuts (for systematic studies [!= -1])
      if( fTPCchi2Cut != -1 && aodTrack->Chi2perNDF() > fTPCchi2Cut){
	continue;
      }
      if( fNClustersTPCCut != -1 && aodTrack->GetTPCNcls() < fNClustersTPCCut){
	continue;
      }

     // Extra cut on shared clusters
      if( fTPCsharedCut != -1 && aodTrack->GetTPCnclsS() > fTPCsharedCut){
	continue;
      }

      //Exclude resonances
      if(fExcludeResonancesInMC) {
	
	Bool_t kExcludeParticle = kFALSE;

	Int_t label = TMath::Abs(aodTrack->GetLabel());
	AliAODMCParticle *AODmcTrack = (AliAODMCParticle*) fArrayMC->At(label);
      
        if (AODmcTrack){ 
	  //if (AODmcTrack->IsPhysicalPrimary()){
	  
	  Int_t gMotherIndex = AODmcTrack->GetMother();
	  if(gMotherIndex != -1) {
	    AliAODMCParticle* motherTrack = dynamic_cast<AliAODMCParticle *>(mcEvent->GetTrack(gMotherIndex));
	    if(motherTrack) {
	      Int_t pdgCodeOfMother = motherTrack->GetPdgCode();
	      if(pdgCodeOfMother == 113  // rho0
		 || pdgCodeOfMother == 213 || pdgCodeOfMother == -213 // rho+
		 // || pdgCodeOfMother == 221  // eta
		 // || pdgCodeOfMother == 331  // eta'
		 // || pdgCodeOfMother == 223  // omega
		 // || pdgCodeOfMother == 333  // phi
		 || pdgCodeOfMother == 311  || pdgCodeOfMother == -311 // K0
		 // || pdgCodeOfMother == 313  || pdgCodeOfMother == -313 // K0*
		 // || pdgCodeOfMother == 323  || pdgCodeOfMother == -323 // K+*
		 || pdgCodeOfMother == 3122 || pdgCodeOfMother == -3122 // Lambda
		 || pdgCodeOfMother == 111  // pi0 Dalitz
		 || pdgCodeOfMother == 22   // photon
		 ) {
		kExcludeParticle = kTRUE;
	      }
	    }
	  }
	}	
	//Exclude from the analysis decay products of rho0, rho+, eta, eta' and phi
	if(kExcludeParticle) continue;
      }

      //Exclude electrons with PDG
      if(fExcludeElectronsInMC) {
	
	Int_t label = TMath::Abs(aodTrack->GetLabel());
	AliAODMCParticle *AODmcTrack = (AliAODMCParticle*) fArrayMC->At(label);
	
        if (AODmcTrack){ 
	  if(TMath::Abs(AODmcTrack->GetPdgCode()) == 11) continue;
	}
      }
      
      // fill QA histograms
      fHistClus->Fill(aodTrack->GetITSNcls(),aodTrack->GetTPCNcls());
      fHistDCA->Fill(dcaZ,dcaXY);
      fHistChi2->Fill(aodTrack->Chi2perNDF(),gCentrality);
      fHistPt->Fill(vPt,gCentrality);
      fHistEta->Fill(vEta,gCentrality);
      fHistRapidity->Fill(vY,gCentrality);
      if(vCharge > 0) fHistPhiPos->Fill(vPhi,gCentrality);
      else if(vCharge < 0) fHistPhiNeg->Fill(vPhi,gCentrality);
      fHistPhi->Fill(vPhi,gCentrality);
      if(vCharge > 0)      fHistEtaPhiPos->Fill(vEta,vPhi,gCentrality); 		 
      else if(vCharge < 0) fHistEtaPhiNeg->Fill(vEta,vPhi,gCentrality);
      
      //=======================================correction
      Double_t correction = GetTrackbyTrackCorrectionMatrix(vEta, vPhi, vPt, vCharge, gCentrality);  
      //Printf("CORRECTIONminus: %.2f | Centrality %lf",correction,gCentrality);
      
      // add the track to the TObjArray
      tracksAccepted->Add(new AliBFBasicParticle(vEta, vPhi, vPt, vCharge, correction));  
    }//track loop
  }//MCAODrec
  //==============================================================================================================

  else if(gAnalysisLevel == "ESD" || gAnalysisLevel == "MCESD") { // handling of TPC only tracks different in AOD and ESD

    AliESDtrack *trackTPC   = NULL;
    AliMCParticle *mcTrack   = NULL;

    AliMCEvent*  mcEvent     = NULL;
    
    // for MC ESDs use also MC information
    if(gAnalysisLevel == "MCESD"){
      mcEvent = MCEvent(); 
      if (!mcEvent) {
	AliError("mcEvent not available");
	return tracksAccepted;
      }
    }
    
    // Loop over tracks in event
    for (Int_t iTracks = 0; iTracks < event->GetNumberOfTracks(); iTracks++) {
      AliESDtrack* track = dynamic_cast<AliESDtrack *>(event->GetTrack(iTracks));
      if (!track) {
	AliError(Form("Could not receive track %d", iTracks));
	continue;
      }	

      // for MC ESDs use also MC information --> MC track not used further???
      if(gAnalysisLevel == "MCESD"){
	Int_t label = TMath::Abs(track->GetLabel());
	if(label > mcEvent->GetNumberOfTracks()) continue;
	if(label > mcEvent->GetNumberOfPrimaries()) continue;
	
	mcTrack = dynamic_cast<AliMCParticle *>(mcEvent->GetTrack(label));
	if(!mcTrack) continue;
      }

      // take only TPC only tracks
      trackTPC   = new AliESDtrack();
      if(!track->FillTPCOnlyTrack(*trackTPC)) continue;
      
      //ESD track cuts
      if(fESDtrackCuts) 
	if(!fESDtrackCuts->AcceptTrack(trackTPC)) continue;
      
      // fill QA histograms
      Float_t b[2];
      Float_t bCov[3];
      trackTPC->GetImpactParameters(b,bCov);
      if (bCov[0]<=0 || bCov[2]<=0) {
	AliDebug(1, "Estimated b resolution lower or equal zero!");
	bCov[0]=0; bCov[2]=0;
      }
      
      Int_t nClustersTPC = -1;
      nClustersTPC = trackTPC->GetTPCNclsIter1();   // TPC standalone
      //nClustersTPC = track->GetTPCclusters(0);   // global track
      Float_t chi2PerClusterTPC = -1;
      if (nClustersTPC!=0) {
	chi2PerClusterTPC = trackTPC->GetTPCchi2Iter1()/Float_t(nClustersTPC);      // TPC standalone
	//chi2PerClusterTPC = track->GetTPCchi2()/Float_t(nClustersTPC);     // global track
      }
      
      //===========================PID===============================//		    
      if(fUsePID) {
	Double_t prob[AliPID::kSPECIES]={0.};
	Double_t probTPC[AliPID::kSPECIES]={0.};
	Double_t probTOF[AliPID::kSPECIES]={0.};
	Double_t probTPCTOF[AliPID::kSPECIES]={0.};
	
	Double_t nSigma = 0.;
	UInt_t detUsedTPC = 0;
	UInt_t detUsedTOF = 0;
	UInt_t detUsedTPCTOF = 0;
	
	//Decide what detector configuration we want to use
	switch(fPidDetectorConfig) {
	case kTPCpid:
	  fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTPC);
	  nSigma = TMath::Abs(fPIDResponse->NumberOfSigmasTPC(track,(AliPID::EParticleType)fParticleOfInterest));
	  detUsedTPC = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTPC);
	  for(Int_t iSpecies = 0; iSpecies < AliPID::kSPECIES; iSpecies++)
	    prob[iSpecies] = probTPC[iSpecies];
	  break;
	case kTOFpid:
	  fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF);
	  nSigma = TMath::Abs(fPIDResponse->NumberOfSigmasTOF(track,(AliPID::EParticleType)fParticleOfInterest));
	  detUsedTOF = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTOF);
	  for(Int_t iSpecies = 0; iSpecies < AliPID::kSPECIES; iSpecies++)
	    prob[iSpecies] = probTOF[iSpecies];
	  break;
	case kTPCTOF:
	  fPIDCombined->SetDetectorMask(AliPIDResponse::kDetTOF|AliPIDResponse::kDetTPC);
	  detUsedTPCTOF = fPIDCombined->ComputeProbabilities(track, fPIDResponse, probTPCTOF);
	  for(Int_t iSpecies = 0; iSpecies < AliPID::kSPECIES; iSpecies++)
	    prob[iSpecies] = probTPCTOF[iSpecies];
	  break;
	default:
	  break;
	}//end switch: define detector mask
	
	//Filling the PID QA
	Double_t tofTime = -999., length = 999., tof = -999.;
	Double_t c = TMath::C()*1.E-9;// m/ns
	Double_t beta = -999.;
	Double_t  nSigmaTOFForParticleOfInterest = -999.;
	if ( (track->IsOn(AliESDtrack::kTOFin)) &&
	     (track->IsOn(AliESDtrack::kTIME))  ) { 
	  tofTime = track->GetTOFsignal();//in ps
	  length = track->GetIntegratedLength();
	  tof = tofTime*1E-3; // ns	
	  
	  if (tof <= 0) {
	    //Printf("WARNING: track with negative TOF time found! Skipping this track for PID checks\n");
	    continue;
	  }
	  if (length <= 0){
	    //printf("WARNING: track with negative length found!Skipping this track for PID checks\n");
	    continue;
	  }
	  
	  length = length*0.01; // in meters
	  tof = tof*c;
	  beta = length/tof;
	  
	  nSigmaTOFForParticleOfInterest = fPIDResponse->NumberOfSigmasTOF(track,(AliPID::EParticleType)fParticleOfInterest);
	  fHistBetavsPTOFbeforePID ->Fill(track->P()*track->Charge(),beta);
	  fHistProbTOFvsPtbeforePID ->Fill(track->Pt(),probTOF[fParticleOfInterest]);
	  fHistNSigmaTOFvsPtbeforePID ->Fill(track->Pt(),nSigmaTOFForParticleOfInterest);
	}//TOF signal 
	
	
	Double_t  nSigmaTPCForParticleOfInterest = fPIDResponse->NumberOfSigmasTPC(track,(AliPID::EParticleType)fParticleOfInterest);
	fHistdEdxVsPTPCbeforePID -> Fill(track->P()*track->Charge(),track->GetTPCsignal());
	fHistProbTPCvsPtbeforePID -> Fill(track->Pt(),probTPC[fParticleOfInterest]); 
	fHistNSigmaTPCvsPtbeforePID -> Fill(track->Pt(),nSigmaTPCForParticleOfInterest); 
	fHistProbTPCTOFvsPtbeforePID -> Fill(track->Pt(),probTPCTOF[fParticleOfInterest]);
	//end of QA-before pid
	
	if ((detUsedTPC != 0)||(detUsedTOF != 0)||(detUsedTPCTOF != 0)) {
	  //Make the decision based on the n-sigma
	  if(fUsePIDnSigma) {
	    if(nSigma > fPIDNSigma) continue;}
	  
	  //Make the decision based on the bayesian
	  else if(fUsePIDPropabilities) {
	    if(fParticleOfInterest != TMath::LocMax(AliPID::kSPECIES,prob)) continue;
	    if (prob[fParticleOfInterest] < fMinAcceptedPIDProbability) continue;      
	  }
	  
	  //Fill QA after the PID
	  fHistBetavsPTOFafterPID ->Fill(track->P()*track->Charge(),beta);
	  fHistProbTOFvsPtafterPID ->Fill(track->Pt(),probTOF[fParticleOfInterest]);
	  fHistNSigmaTOFvsPtafterPID ->Fill(track->Pt(),nSigmaTOFForParticleOfInterest);
	  
	  fHistdEdxVsPTPCafterPID -> Fill(track->P()*track->Charge(),track->GetTPCsignal());
	  fHistProbTPCvsPtafterPID -> Fill(track->Pt(),probTPC[fParticleOfInterest]); 
	  fHistProbTPCTOFvsPtafterPID -> Fill(track->Pt(),probTPCTOF[fParticleOfInterest]);
	  fHistNSigmaTPCvsPtafterPID -> Fill(track->Pt(),nSigmaTPCForParticleOfInterest); 
	}
      }
      //===========================PID===============================//
      vCharge = trackTPC->Charge();
      vY      = trackTPC->Y();
      vEta    = trackTPC->Eta();
      vPhi    = trackTPC->Phi();// * TMath::RadToDeg();
      vPt     = trackTPC->Pt();
      fHistClus->Fill(trackTPC->GetITSclusters(0),nClustersTPC);
      fHistDCA->Fill(b[1],b[0]);
      fHistChi2->Fill(chi2PerClusterTPC,gCentrality);
      fHistPt->Fill(vPt,gCentrality);
      fHistEta->Fill(vEta,gCentrality);
      fHistPhi->Fill(vPhi,gCentrality);
      if(vCharge > 0)      fHistEtaPhiPos->Fill(vEta,vPhi,gCentrality);
      else if(vCharge < 0) fHistEtaPhiNeg->Fill(vEta,vPhi,gCentrality);
      fHistRapidity->Fill(vY,gCentrality);
      if(vCharge > 0) fHistPhiPos->Fill(vPhi,gCentrality);
      else if(vCharge < 0) fHistPhiNeg->Fill(vPhi,gCentrality);
      
      //=======================================correction
      Double_t correction = GetTrackbyTrackCorrectionMatrix(vEta, vPhi, vPt, vCharge, gCentrality);  
      //Printf("CORRECTIONminus: %.2f | Centrality %lf",correction,gCentrality);

      // add the track to the TObjArray
      tracksAccepted->Add(new AliBFBasicParticle(vEta, vPhi, vPt, vCharge, correction));   

      delete trackTPC;
    }//track loop
  }// ESD analysis

  else if(gAnalysisLevel == "MC"){
    if(!event) {
      AliError("mcEvent not available");
      return 0x0;
    }

    AliMCEvent *gMCEvent = dynamic_cast<AliMCEvent*>(event);
    if(gMCEvent) {
      // Loop over tracks in event
      for (Int_t iTracks = 0; iTracks < gMCEvent->GetNumberOfPrimaries(); iTracks++) {
	AliMCParticle* track = dynamic_cast<AliMCParticle *>(gMCEvent->GetTrack(iTracks));
	if (!track) {
	  AliError(Form("Could not receive particle %d", iTracks));
	  continue;
	}
	
	//exclude non stable particles
	if(!(gMCEvent->IsPhysicalPrimary(iTracks))) continue;
	
	vCharge = track->Charge();
	vEta    = track->Eta();
	vPt     = track->Pt();
	vY      = track->Y();
	
	if( vPt < fPtMin || vPt > fPtMax)      
	  continue;
	if (!fUsePID) {
	  if( vEta < fEtaMin || vEta > fEtaMax)  continue;
	}
	else if (fUsePID){
	  if( vY < fEtaMin || vY > fEtaMax)  continue;
	}

	// Remove neutral tracks
	if( vCharge == 0 ) continue;
	
	//analyze one set of particles
	if(fUseMCPdgCode) {
	  TParticle *particle = track->Particle();
	  if(!particle) continue;
	  
	  Int_t gPdgCode = particle->GetPdgCode();
	  if(TMath::Abs(fPDGCodeToBeAnalyzed) != TMath::Abs(gPdgCode)) 
	    continue;
	}
	
	//Use the acceptance parameterization
	if(fAcceptanceParameterization) {
	  Double_t gRandomNumber = gRandom->Rndm();
	  if(gRandomNumber > fAcceptanceParameterization->Eval(track->Pt())) 
	    continue;
	}
	
	//Exclude resonances
	if(fExcludeResonancesInMC) {
	  TParticle *particle = track->Particle();
	  if(!particle) continue;
	  
	  Bool_t kExcludeParticle = kFALSE;
	  Int_t gMotherIndex = particle->GetFirstMother();
	  if(gMotherIndex != -1) {
	    AliMCParticle* motherTrack = dynamic_cast<AliMCParticle *>(event->GetTrack(gMotherIndex));
	    if(motherTrack) {
	      TParticle *motherParticle = motherTrack->Particle();
	      if(motherParticle) {
		Int_t pdgCodeOfMother = motherParticle->GetPdgCode();
		//if((pdgCodeOfMother == 113)||(pdgCodeOfMother == 213)||(pdgCodeOfMother == 221)||(pdgCodeOfMother == 223)||(pdgCodeOfMother == 331)||(pdgCodeOfMother == 333)) {
		if(pdgCodeOfMother == 113  // rho0
		   || pdgCodeOfMother == 213 || pdgCodeOfMother == -213 // rho+
		   // || pdgCodeOfMother == 221  // eta
		   // || pdgCodeOfMother == 331  // eta'
		   // || pdgCodeOfMother == 223  // omega
		   // || pdgCodeOfMother == 333  // phi
		   || pdgCodeOfMother == 311  || pdgCodeOfMother == -311 // K0
		   // || pdgCodeOfMother == 313  || pdgCodeOfMother == -313 // K0*
		   // || pdgCodeOfMother == 323  || pdgCodeOfMother == -323 // K+*
		   || pdgCodeOfMother == 3122 || pdgCodeOfMother == -3122 // Lambda
		   || pdgCodeOfMother == 111  // pi0 Dalitz
		   ) {
		  kExcludeParticle = kTRUE;
		}
	      }
	    }
	  }
	  
	  //Exclude from the analysis decay products of rho0, rho+, eta, eta' and phi
	  if(kExcludeParticle) continue;
	}

	//Exclude electrons with PDG
	if(fExcludeElectronsInMC) {
	  
	  TParticle *particle = track->Particle();
	  
	  if (particle){ 
	    if(TMath::Abs(particle->GetPdgCode()) == 11) continue;
	  }
	}
      
	vPhi    = track->Phi();
	//Printf("phi (before): %lf",vPhi);
	
	fHistPt->Fill(vPt,gCentrality);
	fHistEta->Fill(vEta,gCentrality);
	fHistPhi->Fill(vPhi,gCentrality);
	if(vCharge > 0)      fHistEtaPhiPos->Fill(vEta,vPhi,gCentrality);
	else if(vCharge < 0) fHistEtaPhiNeg->Fill(vEta,vPhi,gCentrality);
	//fHistPhi->Fill(vPhi*TMath::RadToDeg(),gCentrality);
	fHistRapidity->Fill(vY,gCentrality);
	//if(vCharge > 0) fHistPhiPos->Fill(vPhi*TMath::RadToDeg(),gCentrality);
	//else if(vCharge < 0) fHistPhiNeg->Fill(vPhi*TMath::RadToDeg(),gCentrality);
	if(vCharge > 0) fHistPhiPos->Fill(vPhi,gCentrality);
	else if(vCharge < 0) fHistPhiNeg->Fill(vPhi,gCentrality);
	
	//Flow after burner
	if(fUseFlowAfterBurner) {
	  Double_t precisionPhi = 0.001;
	  Int_t maxNumberOfIterations = 100;
	  
	  Double_t phi0 = vPhi;
	  Double_t gV2 = fDifferentialV2->Eval(vPt);
	  
	  for (Int_t j = 0; j < maxNumberOfIterations; j++) {
	    Double_t phiprev = vPhi;
	    Double_t fl = vPhi - phi0 + gV2*TMath::Sin(2.*(vPhi - gReactionPlane*TMath::DegToRad()));
	    Double_t fp = 1.0 + 2.0*gV2*TMath::Cos(2.*(vPhi - gReactionPlane*TMath::DegToRad())); 
	    vPhi -= fl/fp;
	    if (TMath::AreEqualAbs(phiprev,vPhi,precisionPhi)) break;
	  }
	  //Printf("phi (after): %lf\n",vPhi);
	  Double_t vDeltaphiBefore = phi0 - gReactionPlane*TMath::DegToRad();
	  if(vDeltaphiBefore < 0) vDeltaphiBefore += 2*TMath::Pi();
	  fHistPhiBefore->Fill(vDeltaphiBefore,gCentrality);
	  
	  Double_t vDeltaphiAfter = vPhi - gReactionPlane*TMath::DegToRad();
	  if(vDeltaphiAfter < 0) vDeltaphiAfter += 2*TMath::Pi();
	  fHistPhiAfter->Fill(vDeltaphiAfter,gCentrality);
	  
	}
	
	//vPhi *= TMath::RadToDeg();
	
      //=======================================correction
      Double_t correction = GetTrackbyTrackCorrectionMatrix(vEta, vPhi, vPt, vCharge, gCentrality);  
      //Printf("CORRECTIONminus: %.2f | Centrality %lf",correction,gCentrality);

	tracksAccepted->Add(new AliBFBasicParticle(vEta, vPhi, vPt, vCharge, correction)); 
      } //track loop
    }//MC event object
  }//MC
  
  return tracksAccepted;  
}

//________________________________________________________________________
TObjArray* AliAnalysisTaskBFPsi::GetShuffledTracks(TObjArray *tracks, Double_t gCentrality){
  // Clones TObjArray and returns it with tracks after shuffling the charges

  TObjArray* tracksShuffled = new TObjArray;
  tracksShuffled->SetOwner(kTRUE);

  vector<Short_t> *chargeVector = new vector<Short_t>;   //original charge of accepted tracks 

  for (Int_t i=0; i<tracks->GetEntriesFast(); i++)
  {
    AliVParticle* track = (AliVParticle*) tracks->At(i);
    chargeVector->push_back(track->Charge());
  }  
 
  random_shuffle(chargeVector->begin(), chargeVector->end());
  
  for(Int_t i = 0; i < tracks->GetEntriesFast(); i++){
    AliVParticle* track = (AliVParticle*) tracks->At(i);
    //==============================correction
    Double_t correction = GetTrackbyTrackCorrectionMatrix(track->Eta(), track->Phi(),track->Pt(), chargeVector->at(i), gCentrality);
    //Printf("CORRECTIONminus: %.2f | Centrality %lf",correction,gCentrality);
    tracksShuffled->Add(new AliBFBasicParticle(track->Eta(), track->Phi(), track->Pt(),chargeVector->at(i), correction));
  }

  delete chargeVector;
   
  return tracksShuffled;
}

//________________________________________________________________________
void  AliAnalysisTaskBFPsi::SetVZEROCalibrationFile(const char* filename,
						    const char* lhcPeriod) {
  //Function to setup the VZERO gain equalization
    //============Get the equilization map============//
  TFile *calibrationFile = TFile::Open(filename);
  if((!calibrationFile)||(!calibrationFile->IsOpen())) {
    Printf("No calibration file found!!!");
    return;
  }

  TList *list = dynamic_cast<TList *>(calibrationFile->Get(lhcPeriod));
  if(!list) {
    Printf("Calibration TList not found!!!");
    return;
  }

  fHistVZEROAGainEqualizationMap = dynamic_cast<TH1F *>(list->FindObject("gHistVZEROAGainEqualizationMap"));
  if(!fHistVZEROAGainEqualizationMap) {
    Printf("VZERO-A calibration object not found!!!");
    return;
  }
  fHistVZEROCGainEqualizationMap = dynamic_cast<TH1F *>(list->FindObject("gHistVZEROCGainEqualizationMap"));
  if(!fHistVZEROCGainEqualizationMap) {
    Printf("VZERO-C calibration object not found!!!");
    return;
  }

  fHistVZEROChannelGainEqualizationMap = dynamic_cast<TH2F *>(list->FindObject("gHistVZEROChannelGainEqualizationMap"));
  if(!fHistVZEROChannelGainEqualizationMap) {
    Printf("VZERO channel calibration object not found!!!");
    return;
  }
}

//________________________________________________________________________
Double_t AliAnalysisTaskBFPsi::GetChannelEqualizationFactor(Int_t run, 
							    Int_t channel) {
  //
  if(!fHistVZEROAGainEqualizationMap) return 1.0;

  for(Int_t iBinX = 1; iBinX <= fHistVZEROChannelGainEqualizationMap->GetNbinsX(); iBinX++) {
    Int_t gRunNumber = atoi(fHistVZEROChannelGainEqualizationMap->GetXaxis()->GetBinLabel(iBinX));
    if(gRunNumber == run)
      return fHistVZEROChannelGainEqualizationMap->GetBinContent(iBinX,channel+1);
  }

  return 1.0;
}

//________________________________________________________________________
Double_t AliAnalysisTaskBFPsi::GetEqualizationFactor(Int_t run, 
						     const char* side) {
  //
  if(!fHistVZEROAGainEqualizationMap) return 1.0;

  TString gVZEROSide = side;
  for(Int_t iBinX = 1; iBinX < fHistVZEROAGainEqualizationMap->GetNbinsX(); iBinX++) {
    Int_t gRunNumber = atoi(fHistVZEROAGainEqualizationMap->GetXaxis()->GetBinLabel(iBinX));
    //cout<<"Looking for run "<<run<<" - current run: "<<gRunNumber<<endl;
    if(gRunNumber == run) {
      if(gVZEROSide == "A") 
	return fHistVZEROAGainEqualizationMap->GetBinContent(iBinX);
      else if(gVZEROSide == "C") 
	return fHistVZEROCGainEqualizationMap->GetBinContent(iBinX);
    }
  }

  return 1.0;
}

//____________________________________________________________________
Bool_t AliAnalysisTaskBFPsi::AcceptEventCentralityWeight(Double_t centrality)
{
  // copied from AliAnalysisTaskPhiCorrelations
  //
  // rejects "randomly" events such that the centrality gets flat
  // uses fCentralityWeights histogram

  // TODO code taken and adapted from AliRDHFCuts; waiting for general class AliCentralityFlattening
  
  Double_t weight = fCentralityWeights->GetBinContent(fCentralityWeights->FindBin(centrality));
  Double_t centralityDigits = centrality*100. - (Int_t)(centrality*100.);
  
  Bool_t result = kFALSE;
  if (centralityDigits < weight) 
    result = kTRUE;
  
  AliInfo(Form("Centrality: %f; Digits: %f; Weight: %f; Result: %d", centrality, centralityDigits, weight, result));
  
  return result;
}

//________________________________________________________________________
void  AliAnalysisTaskBFPsi::FinishTaskOutput(){
  //Printf("END BF");

  if (!fBalance) {
    AliError("fBalance not available");
    return;
  }  
  if(fRunShuffling) {
    if (!fShuffledBalance) {
      AliError("fShuffledBalance not available");
      return;
    }
  }

}

//________________________________________________________________________
void AliAnalysisTaskBFPsi::Terminate(Option_t *) {
  // Draw result to the screen
  // Called once at the end of the query

  // not implemented ...

}

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