ROOT logo
#include <vector>
#include "TChain.h"
#include "TList.h"
#include "TCanvas.h"
#include "TLorentzVector.h"
#include "TGraphErrors.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TArrayF.h"
#include "TF1.h"
#include "TRandom.h"

#include "AliLog.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 "AliGenEventHeader.h"
#include "AliGenHijingEventHeader.h"
#include "AliMCEventHandler.h"
#include "AliMCEvent.h"
#include "AliMixInputEventHandler.h"
#include "AliStack.h"

#include "TH2D.h"    
#include "AliTHn.h"             

#include "AliEventPoolManager.h" 

#include "AliAnalysisTaskTriggeredBF.h"
#include "AliBalanceTriggered.h"


// Analysis task for the TriggeredBF code
// Authors: Panos.Christakoglou@nikhef.nl, m.weber@cern.ch

// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//
// For the V0 part:
// --> AliAnalysisTaskExtractV0AOD (by david.chinellato@gmail.com)
//
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

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

ClassImp(AliAnalysisTaskTriggeredBF)

//________________________________________________________________________
AliAnalysisTaskTriggeredBF::AliAnalysisTaskTriggeredBF(const char *name) 
: AliAnalysisTaskSE(name), 
  fBalance(0),
  fRunShuffling(kFALSE),
  fShuffledBalance(0),
  fRunMixing(kFALSE),
  fMixingTracks(50000),
  fMixedBalance(0),
  fPoolMgr(0),
  fRunV0(kFALSE),
  fPIDResponse(0),
  fPIDCombined(0),
  fList(0),
  fListTriggeredBF(0),
  fListTriggeredBFS(0),
  fListTriggeredBFM(0),
  fHistListPIDQA(0),
  fHistListV0(0),
  fHistEventStats(0),
  fHistCentStats(0),
  fHistTriggerStats(0),
  fHistTrackStats(0),
  fHistVx(0),
  fHistVy(0),
  fHistVz(0),
  fHistClus(0),
  fHistDCA(0),
  fHistChi2(0),
  fHistPt(0),
  fHistEta(0),
  fHistPhi(0),
  fHistPhiBefore(0),
  fHistPhiAfter(0),
  fHistV0M(0),
  fHistRefTracks(0),
  fHistV0MultiplicityBeforeTrigSel(0),
  fHistV0MultiplicityForTrigEvt(0),
  fHistV0MultiplicityForSelEvt(0),
  fHistV0MultiplicityForSelEvtNoTPCOnly(0),
  fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup(0),
  fHistMultiplicityBeforeTrigSel(0),
  fHistMultiplicityForTrigEvt(0),
  fHistMultiplicity(0),
  fHistMultiplicityNoTPCOnly(0),
  fHistMultiplicityNoTPCOnlyNoPileup(0),
  fHistV0InvMassK0(0),
  fHistV0InvMassLambda(0),
  fHistV0InvMassAntiLambda(0),
  fHistV0Armenteros(0),
  fHistV0SelInvMassK0(0),
  fHistV0SelInvMassLambda(0),
  fHistV0SelInvMassAntiLambda(0),
  fHistV0SelArmenteros(0),
  fCentralityEstimator("V0M"),
  fUseCentrality(kFALSE),
  fCentralityPercentileMin(0.), 
  fCentralityPercentileMax(5.),
  fImpactParameterMin(0.),
  fImpactParameterMax(20.),
  fUseMultiplicity(kFALSE),
  fNumberOfAcceptedTracksMin(0),
  fNumberOfAcceptedTracksMax(10000),
  fHistNumberOfAcceptedTracks(0),
  fUseOfflineTrigger(kFALSE),
  fVxMax(0.3),
  fVyMax(0.3),
  fVzMax(10.),
  nAODtrackCutBit(128),
  fPtMin(0.3),
  fPtMax(1.5),
  fEtaMin(-0.8),
  fEtaMax(-0.8),
  fDCAxyCut(-1),
  fDCAzCut(-1),
  fTPCchi2Cut(-1),
  fNClustersTPCCut(-1)
{
  // Constructor
  // Define input and output slots here
  // Input slot #0 works with a TChain
  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());
}

//________________________________________________________________________
AliAnalysisTaskTriggeredBF::~AliAnalysisTaskTriggeredBF() {

  // Destructor

}

//________________________________________________________________________
void AliAnalysisTaskTriggeredBF::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 AliBalanceTriggered();
    fBalance->SetAnalysisLevel("AOD");
  }
  if(fRunShuffling) {
    if(!fShuffledBalance) {
      fShuffledBalance = new AliBalanceTriggered();
      fShuffledBalance->SetAnalysisLevel("AOD");
    }
  }
  if(fRunMixing) {
    if(!fMixedBalance) {
      fMixedBalance = new AliBalanceTriggered();
      fMixedBalance->SetAnalysisLevel("AOD");
    }
  }

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

  //Balance Function list
  fListTriggeredBF = new TList();
  fListTriggeredBF->SetName("listTriggeredBF");
  fListTriggeredBF->SetOwner();

  if(fRunShuffling) {
    fListTriggeredBFS = new TList();
    fListTriggeredBFS->SetName("listTriggeredBFShuffled");
    fListTriggeredBFS->SetOwner();
  }
  if(fRunMixing) {
    fListTriggeredBFM = new TList();
    fListTriggeredBFM->SetName("listTriggeredBFMixed");
    fListTriggeredBFM->SetOwner();
  }
  
  
  //Event stats.
  TString gCutName[4] = {"Total","Offline trigger",
                         "Vertex","Analyzed"};
  fHistEventStats = new TH1F("fHistEventStats",
                             "Event statistics;;N_{events}",
                             4,0.5,4.5);
  for(Int_t i = 1; i <= 4; i++)
    fHistEventStats->GetXaxis()->SetBinLabel(i,gCutName[i-1].Data());
  fList->Add(fHistEventStats);
  
  TString gCentName[9] = {"V0M","FMD","TRK","TKL","CL0","CL1","V0MvsFMD","TKLvsV0M","ZEMvsZDC"};
  fHistCentStats = new TH2F("fHistCentStats",
			    "Centrality statistics;;Cent percentile",
			    9,-0.5,8.5,220,-5,105);
  for(Int_t i = 1; i <= 9; i++)
    fHistCentStats->GetXaxis()->SetBinLabel(i,gCentName[i-1].Data());
  fList->Add(fHistCentStats);
  
  fHistTriggerStats = new TH1F("fHistTriggerStats","Trigger statistics;TriggerBit;N_{events}",130,0,130);
  fList->Add(fHistTriggerStats);
  
  fHistTrackStats = new TH1F("fHistTrackStats","Event statistics;TrackFilterBit;N_{events}",130,0,130);
  fList->Add(fHistTrackStats);

  fHistNumberOfAcceptedTracks = new TH1F("fHistNumberOfAcceptedTracks",";N_{acc.};Entries",4001,-0.5,4000.5);
  fList->Add(fHistNumberOfAcceptedTracks);

  // 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 TH1F("fHistVz","Primary vertex distribution - z coordinate;V_{z} (cm);Entries",100,-20.,20.);
  fList->Add(fHistVz);

  // QA histograms
  fHistClus = new TH2F("fHistClus","# Cluster (TPC vs. ITS)",10,0,10,200,0,200);
  fList->Add(fHistClus);
  fHistChi2 = new TH1F("fHistChi2","Chi2/NDF distribution",200,0,10);
  fList->Add(fHistChi2);
  fHistDCA  = new TH2F("fHistDCA","DCA (xy vs. z)",400,-5,5,400,-5,5); 
  fList->Add(fHistDCA);
  fHistPt   = new TH1F("fHistPt","p_{T} distribution",200,0,10);
  fList->Add(fHistPt);
  fHistEta  = new TH1F("fHistEta","#eta distribution",200,-2,2);
  fList->Add(fHistEta);
  fHistPhi  = new TH1F("fHistPhi","#phi distribution",200,-20,380);
  fList->Add(fHistPhi);
  fHistPhiBefore  = new TH1F("fHistPhiBefore","#phi distribution",200,0.,2*TMath::Pi());
  fList->Add(fHistPhiBefore);
  fHistPhiAfter  = new TH1F("fHistPhiAfter","#phi distribution",200,0.,2*TMath::Pi());
  fList->Add(fHistPhiAfter);
  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);

  //------------------------------------------------
  // V0 Multiplicity Histograms
  //------------------------------------------------
  if(fRunV0){
    fHistListV0 = new TList();
    fHistListV0->SetOwner();  // See http://root.cern.ch/root/html/TCollection.html#TCollection:SetOwner
    
    if(! fHistV0MultiplicityBeforeTrigSel) {
      fHistV0MultiplicityBeforeTrigSel = new TH1F("fHistV0MultiplicityBeforeTrigSel", 
						  "V0s per event (before Trig. Sel.);Nbr of V0s/Evt;Events", 
						  25, 0, 25);
      fHistListV0->Add(fHistV0MultiplicityBeforeTrigSel);
    }
    
    if(! fHistV0MultiplicityForTrigEvt) {
      fHistV0MultiplicityForTrigEvt = new TH1F("fHistV0MultiplicityForTrigEvt", 
					       "V0s per event (for triggered evt);Nbr of V0s/Evt;Events", 
					       25, 0, 25);
      fHistListV0->Add(fHistV0MultiplicityForTrigEvt);
    }
    
    if(! fHistV0MultiplicityForSelEvt) {
      fHistV0MultiplicityForSelEvt = new TH1F("fHistV0MultiplicityForSelEvt", 
					      "V0s per event;Nbr of V0s/Evt;Events", 
					      25, 0, 25);
      fHistListV0->Add(fHistV0MultiplicityForSelEvt);
    }
    
    if(! fHistV0MultiplicityForSelEvtNoTPCOnly) {
    fHistV0MultiplicityForSelEvtNoTPCOnly = new TH1F("fHistV0MultiplicityForSelEvtNoTPCOnly", 
						     "V0s per event;Nbr of V0s/Evt;Events", 
						     25, 0, 25);
    fHistListV0->Add(fHistV0MultiplicityForSelEvtNoTPCOnly);
    }
    
    if(! fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup) {
      fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup = new TH1F("fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup", 
							     "V0s per event;Nbr of V0s/Evt;Events", 
							       25, 0, 25);
      fHistListV0->Add(fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup);
    }
    
    //------------------------------------------------
    // Track Multiplicity Histograms
    //------------------------------------------------
    
    if(! fHistMultiplicityBeforeTrigSel) {
      fHistMultiplicityBeforeTrigSel = new TH1F("fHistMultiplicityBeforeTrigSel", 
					      "Tracks per event;Nbr of Tracks;Events", 
						200, 0, 200); 		
      fHistListV0->Add(fHistMultiplicityBeforeTrigSel);
    }
    if(! fHistMultiplicityForTrigEvt) {
      fHistMultiplicityForTrigEvt = new TH1F("fHistMultiplicityForTrigEvt", 
					     "Tracks per event;Nbr of Tracks;Events", 
					     200, 0, 200); 		
      fHistListV0->Add(fHistMultiplicityForTrigEvt);
    }
    if(! fHistMultiplicity) {
      fHistMultiplicity = new TH1F("fHistMultiplicity", 
				   "Tracks per event;Nbr of Tracks;Events", 
				   200, 0, 200); 		
      fHistListV0->Add(fHistMultiplicity);
    }
    if(! fHistMultiplicityNoTPCOnly) {
      fHistMultiplicityNoTPCOnly = new TH1F("fHistMultiplicityNoTPCOnly", 
					    "Tracks per event;Nbr of Tracks;Events", 
					    200, 0, 200); 		
    fHistListV0->Add(fHistMultiplicityNoTPCOnly);
    }
    if(! fHistMultiplicityNoTPCOnlyNoPileup) {
      fHistMultiplicityNoTPCOnlyNoPileup = new TH1F("fHistMultiplicityNoTPCOnlyNoPileup", 
						    "Tracks per event;Nbr of Tracks;Events", 
						    200, 0, 200); 		
      fHistListV0->Add(fHistMultiplicityNoTPCOnlyNoPileup);
    }

    //------------------------------------------------
    // V0 selection Histograms (before)
    //------------------------------------------------
    if(!fHistV0InvMassK0) {
      fHistV0InvMassK0 = new TH1F("fHistV0InvMassK0",
				  "Invariant Mass for K0;Mass (GeV/c^{2});Events",
				  200,0,2);
      fHistListV0->Add(fHistV0InvMassK0);
    }
    if(!fHistV0InvMassLambda) {
      fHistV0InvMassLambda = new TH1F("fHistV0InvMassLambda",
				  "Invariant Mass for Lambda;Mass (GeV/c^{2});Events",
				  200,0,2);
      fHistListV0->Add(fHistV0InvMassLambda);
    }
    if(!fHistV0InvMassAntiLambda) {
      fHistV0InvMassAntiLambda = new TH1F("fHistV0InvMassAntiLambda",
				  "Invariant Mass for AntiLambda;Mass (GeV/c^{2});Events",
				  200,0,2);
      fHistListV0->Add(fHistV0InvMassAntiLambda);
    }
    if(!fHistV0Armenteros) {
      fHistV0Armenteros = new TH2F("fHistV0Armenteros",
				  "Armenteros plot;#alpha;q_{t}",
				   200,-1,1,200,0,0.5);
      fHistListV0->Add(fHistV0Armenteros);
    }
    
    //------------------------------------------------
    // V0 selection Histograms (after)
    //------------------------------------------------
    if(!fHistV0SelInvMassK0) {
      fHistV0SelInvMassK0 = new TH1F("fHistV0SelInvMassK0",
				  "Invariant Mass for K0;Mass (GeV/c^{2});Events",
				  200,0,2);
      fHistListV0->Add(fHistV0SelInvMassK0);
    }
    if(!fHistV0SelInvMassLambda) {
      fHistV0SelInvMassLambda = new TH1F("fHistV0SelInvMassLambda",
				  "Invariant Mass for Lambda;Mass (GeV/c^{2});Events",
				  200,0,2);
      fHistListV0->Add(fHistV0SelInvMassLambda);
    }
    if(!fHistV0SelInvMassAntiLambda) {
      fHistV0SelInvMassAntiLambda = new TH1F("fHistV0SelInvMassAntiLambda",
				  "Invariant Mass for AntiLambda;Mass (GeV/c^{2});Events",
				  200,0,2);
      fHistListV0->Add(fHistV0SelInvMassAntiLambda);
    }
    if(!fHistV0SelArmenteros) {
      fHistV0SelArmenteros = new TH2F("fHistV0SelArmenteros",
				  "Armenteros plot;#alpha;q_{t}",
				   200,-1,1,200,0,0.5);
      fHistListV0->Add(fHistV0SelArmenteros);
    }
  }//V0
    
  // Balance function histograms
  // Initialize histograms if not done yet
  if(!fBalance->GetHistNp()){
    AliWarning("Histograms not yet initialized! --> Will be done now");
    AliWarning("--> Add 'gBalance->InitHistograms()' in your configBalanceFunction");
    fBalance->InitHistograms();
  }

  if(fRunShuffling) {
    if(!fShuffledBalance->GetHistNp()) {
      AliWarning("Histograms (shuffling) not yet initialized! --> Will be done now");
      AliWarning("--> Add 'gBalance->InitHistograms()' in your configBalanceFunction");
      fShuffledBalance->InitHistograms();
    }
  }

  if(fRunMixing) {
    if(!fMixedBalance->GetHistNp()) {
      AliWarning("Histograms (mixing) not yet initialized! --> Will be done now");
      AliWarning("--> Add 'gBalance->InitHistograms()' in your configBalanceFunction");
      fMixedBalance->InitHistograms();
    }
  }

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

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

  // PID Response task active?
  if(fRunV0) {
    fPIDResponse = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->GetPIDResponse();
    if (!fPIDResponse) AliFatal("This Task needs the PID response attached to the inputHandler");
  }

  // Event Mixing
  Int_t trackDepth = fMixingTracks; 
  Int_t poolsize   = 1000;  // Maximum number of events, ignored in the present implemented of AliEventPoolManager
   
  Double_t centralityBins[] = {0.,1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,15.,20.,25.,30.,35.,40.,45.,50.,55.,60.,65.,70.,75.,80.,90.,100.}; // SHOULD BE DEDUCED FROM CREATED ALITHN!!!
  Double_t* centbins        = centralityBins;
  Int_t nCentralityBins     = sizeof(centralityBins) / sizeof(Double_t) - 1;
  
  // bins for second buffer are shifted by 100 cm
  Double_t vertexBins[] = {-10., -7., -5., -3., -1., 1., 3., 5., 7., 10.}; // SHOULD BE DEDUCED FROM CREATED ALITHN!!!
  Double_t* vtxbins     = vertexBins;
  Int_t nVertexBins     = sizeof(vertexBins) / sizeof(Double_t) - 1;

  fPoolMgr = new AliEventPoolManager(poolsize, trackDepth, nCentralityBins, centbins, nVertexBins, vtxbins);


  // Post output data.
  PostData(1, fList);
  PostData(2, fListTriggeredBF);
  if(fRunShuffling) PostData(3, fListTriggeredBFS);
  if(fRunMixing) PostData(4, fListTriggeredBFM);
  if(fRunV0) PostData(5,fHistListV0);

  TH1::AddDirectory(oldStatus);

}

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

  TString gAnalysisLevel = fBalance->GetAnalysisLevel();
  Float_t fCentrality = -1.;  

  // -------------------------------------------------------------		     
  // AOD analysis (vertex and track cuts also here!!!!)
  if(gAnalysisLevel == "AOD") {
    AliVEvent* eventMain = dynamic_cast<AliVEvent*>(InputEvent()); 
    if(!eventMain) {
      AliError("eventMain not available");
      return;
    }

    // check event cuts and fill event histograms
    if((fCentrality = IsEventAccepted(eventMain)) < 0){
      return;
    }
    
    // get the accepted tracks in main event
    TObjArray *tracksMain = NULL;
    if(fRunV0) tracksMain = GetAcceptedV0s(eventMain);
    else       tracksMain = GetAcceptedTracks(eventMain);

    // store charges of all accepted tracks, shuffle and reassign (two extra loops!)
    TObjArray* tracksShuffled = NULL;
    if(fRunShuffling){
      tracksShuffled = GetShuffledTracks(tracksMain);
    }
    
    // Event mixing --> UPDATE POOL IS MISSING!!!
    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(fCentrality, eventMain->GetPrimaryVertex()->GetZ());
	
	if (!pool){
	  AliFatal(Form("No pool found for centrality = %f, zVtx = %f", fCentrality, eventMain->GetPrimaryVertex()->GetZ()));
	}
	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->FillBalance(fCentrality,tracksMain,tracksMixed); 
	      }
	  }
	  
	  // Update the Event pool
	  pool->UpdatePool(tracksMain);
	  //pool->PrintInfo();
	  
	}//pool NULL check  
      }//run mixing
    
    // calculate balance function
    fBalance->FillBalance(fCentrality,tracksMain,NULL);
    
    // calculate shuffled balance function
    if(fRunShuffling && tracksShuffled != NULL) {
      fShuffledBalance->FillBalance(fCentrality,tracksShuffled,NULL);
    }
    
  }//AOD analysis
  else{
    AliError("Triggered Balance Function analysis only for AODs!");
  }
}     

//________________________________________________________________________
Float_t AliAnalysisTaskTriggeredBF::IsEventAccepted(AliVEvent *event){
  // Checks the Event cuts
  // Fills Event statistics histograms
  
  // event selection done in AliAnalysisTaskSE::Exec() --> this is not used
  fHistEventStats->Fill(1); //all events

  Bool_t isSelectedMain = kTRUE;
  Float_t fCentrality = -1.;
  Int_t nV0s          = event->GetNumberOfV0s();
  TString gAnalysisLevel = fBalance->GetAnalysisLevel();
  
  if(fUseOfflineTrigger)
    isSelectedMain = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
  
  //V0 QA histograms (before trigger selection)
  if(fRunV0){
    fHistMultiplicityBeforeTrigSel->Fill ( -1 );
    fHistV0MultiplicityBeforeTrigSel->Fill ( nV0s );
  }
  
  if(isSelectedMain) {
    fHistEventStats->Fill(2); //triggered events
    
    //Centrality stuff 
    if(fUseCentrality) {
      if(gAnalysisLevel == "AOD") { //centrality in AOD header
	AliAODHeader *header = (AliAODHeader*) event->GetHeader();
	fCentrality = header->GetCentralityP()->GetCentralityPercentile(fCentralityEstimator.Data());

	// QA for centrality estimators
	fHistCentStats->Fill(0.,header->GetCentralityP()->GetCentralityPercentile("V0M"));
	fHistCentStats->Fill(1.,header->GetCentralityP()->GetCentralityPercentile("FMD"));
	fHistCentStats->Fill(2.,header->GetCentralityP()->GetCentralityPercentile("TRK"));
	fHistCentStats->Fill(3.,header->GetCentralityP()->GetCentralityPercentile("TKL"));
	fHistCentStats->Fill(4.,header->GetCentralityP()->GetCentralityPercentile("CL0"));
	fHistCentStats->Fill(5.,header->GetCentralityP()->GetCentralityPercentile("CL1"));
	fHistCentStats->Fill(6.,header->GetCentralityP()->GetCentralityPercentile("V0MvsFMD"));
	fHistCentStats->Fill(7.,header->GetCentralityP()->GetCentralityPercentile("TKLvsV0M"));
	fHistCentStats->Fill(8.,header->GetCentralityP()->GetCentralityPercentile("ZEMvsZDC"));
	
	// 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));

	//V0 QA histograms (after trigger selection)
	if(fRunV0){
	  fHistMultiplicityForTrigEvt->Fill ( fCentrality );
	  fHistV0MultiplicityForTrigEvt->Fill ( nV0s );
	}
      }
    }
    
    
    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); //events with a proper vertex
	  if(TMath::Abs(vertex->GetX()) < fVxMax) {
	    if(TMath::Abs(vertex->GetY()) < fVyMax) {
	      if(TMath::Abs(vertex->GetZ()) < fVzMax) {
		fHistEventStats->Fill(4); //analyzed events
		fHistVx->Fill(vertex->GetX());
		fHistVy->Fill(vertex->GetY());
		fHistVz->Fill(vertex->GetZ());



		//V0 QA histograms (vertex Z check)
		if(fRunV0){
		  fHistV0MultiplicityForSelEvt ->Fill( nV0s );
		  fHistMultiplicity->Fill(fCentrality);

		  //V0 QA histograms (Only look at events with well-established PV)
		  const AliAODVertex *lPrimarySPDVtx = ((AliAODEvent*)event)->GetPrimaryVertexSPD();
		  if(lPrimarySPDVtx){
		    fHistMultiplicityNoTPCOnly->Fill ( fCentrality );
		    fHistV0MultiplicityForSelEvtNoTPCOnly->Fill ( nV0s );
		    
		    //V0 QA histograms (Pileup Rejection)
		    // FIXME : quality selection regarding pile-up rejection 
		    fHistMultiplicityNoTPCOnlyNoPileup->Fill(fCentrality);
		    fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup ->Fill( nV0s );

		  }
		  else{
		    return -1;
		  }
		}
		
		
		// take only events inside centrality class
		if((fCentrality > fCentralityPercentileMin) && (fCentrality < fCentralityPercentileMax)){
		  return fCentrality;		
		}//centrality class
	      }//Vz cut
	    }//Vy cut
	  }//Vx cut
	}//proper vertex resolution
      }//proper number of contributors
    }//vertex object valid
  }//triggered event 
  
  // in all other cases return -1 (event not accepted)
  return -1;
}

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

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

  Short_t vCharge = 0;
  Double_t vEta    = 0.;
  Double_t vPhi    = 0.;
  Double_t vPt     = 0.;
  
  // 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());
    if(!aodTrack->TestFilterBit(nAODtrackCutBit)) continue;
    
    vCharge = aodTrack->Charge();
    vEta    = aodTrack->Eta();
    vPhi    = aodTrack->Phi() * TMath::RadToDeg();
    vPt     = aodTrack->Pt();
    
    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;
    }
    
    // fill QA histograms
    fHistClus->Fill(aodTrack->GetITSNcls(),aodTrack->GetTPCNcls());
    fHistDCA->Fill(dcaZ,dcaXY);
    fHistChi2->Fill(aodTrack->Chi2perNDF());
    fHistPt->Fill(vPt);
    fHistEta->Fill(vEta);
    fHistPhi->Fill(vPhi);
    
    // add the track to the TObjArray
    tracksAccepted->Add(new AliBFBasicParticle(vEta, vPhi, vPt, vCharge,1.));
  }

  return tracksAccepted;
}

//________________________________________________________________________
TObjArray* AliAnalysisTaskTriggeredBF::GetAcceptedV0s(AliVEvent *event){
  // Returns TObjArray with tracks after all track cuts (only for AOD!)
  // Fills QA histograms

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

  Short_t vCharge = 0;
  Double_t vEta    = 0.;
  Double_t vPhi    = 0.;
  Double_t vPt     = 0.;
  
  //------------------------------------------------
  // MAIN LAMBDA LOOP STARTS HERE (basically a copy of AliAnalysisTaskExtractV0AOD)
  //------------------------------------------------

  // parameters (for the time being hard coded here) --> from David for EbyE Lambdas
  Bool_t fkUseOnTheFly = kFALSE;
  Double_t fRapidityBoundary  = 0.5; 
  Double_t fCutDaughterEta    = 0.8;
  Double_t fCutV0Radius       = 0.9;
  Double_t fCutDCANegToPV     = 0.1;
  Double_t fCutDCAPosToPV     = 0.1;
  Double_t fCutDCAV0Daughters = 1.0;
  Double_t fCutV0CosPA        = 0.9995;
  Double_t fMassLambda        = 1.115683;
  Double_t fCutMassLambda     = 0.007;
  Double_t fCutProperLifetime = 3*7.9;
  Double_t fCutLeastNumberOfCrossedRows = 70;
  Double_t fCutLeastNumberOfCrossedRowsOverFindable = 0.8;
  Double_t fCutTPCPIDNSigmasProton  = 3.0;
  Double_t fCutTPCPIDNSigmasPion    = 5.0;


  //Variable definition
  Int_t    lOnFlyStatus = 0;// nv0sOn = 0, nv0sOff = 0;
  Double_t lChi2V0 = 0;
  Double_t lDcaV0Daughters = 0, lDcaV0ToPrimVertex = 0;
  Double_t lDcaPosToPrimVertex = 0, lDcaNegToPrimVertex = 0;
  Double_t lV0CosineOfPointingAngle = 0;
  Double_t lV0Radius = 0, lPt = 0;
  Double_t lEta = 0, lPhi = 0;
  Double_t lRap = 0, lRapK0Short = 0, lRapLambda = 0;
  Double_t lInvMassK0s = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0;
  Double_t lAlphaV0 = 0, lPtArmV0 = 0;
  
  Double_t fMinV0Pt = 0; 
  Double_t fMaxV0Pt = 100; 
  

  
  // some event observables
  Int_t nv0s = event->GetNumberOfV0s();
  Double_t tPrimaryVtxPosition[3];
  const AliVVertex *primaryVtx = event->GetPrimaryVertex();
  tPrimaryVtxPosition[0] = primaryVtx->GetX();
  tPrimaryVtxPosition[1] = primaryVtx->GetY();
  tPrimaryVtxPosition[2] = primaryVtx->GetZ();


  //loop over V0s  
  for (Int_t iV0 = 0; iV0 < nv0s; iV0++) 
    {// This is the begining of the V0 loop
      AliAODv0 *v0 = ((AliAODEvent*)event)->GetV0(iV0);
      if (!v0) continue;

      //Obsolete at AOD level... 
      //---> Fix On-the-Fly candidates, count how many swapped
      //if( v0->GetParamN()->Charge() > 0 && v0->GetParamP()->Charge() < 0 ){
      //  fHistSwappedV0Counter -> Fill( 1 );
      //}else{
      //  fHistSwappedV0Counter -> Fill( 0 ); 
      //}
      //if ( fkUseOnTheFly ) CheckChargeV0(v0); 
      
      Double_t tDecayVertexV0[3]; v0->GetXYZ(tDecayVertexV0); 
      Double_t tV0mom[3];
      v0->GetPxPyPz( tV0mom ); 
      Double_t lV0TotalMomentum = TMath::Sqrt(
					      tV0mom[0]*tV0mom[0]+tV0mom[1]*tV0mom[1]+tV0mom[2]*tV0mom[2] );
      
      lV0Radius = TMath::Sqrt(tDecayVertexV0[0]*tDecayVertexV0[0]+tDecayVertexV0[1]*tDecayVertexV0[1]);
      lPt = v0->Pt();
      lEta = v0->Eta();
      lPhi = v0->Phi()*TMath::RadToDeg();
      lRapK0Short = v0->RapK0Short();
      lRapLambda  = v0->RapLambda();
      lRap        = lRapLambda;//v0->Y(); //FIXME!!!
      if ((lPt<fMinV0Pt)||(fMaxV0Pt<lPt)) continue;
      
      //UInt_t lKeyPos = (UInt_t)TMath::Abs(v0->GetPosID());
      //UInt_t lKeyNeg = (UInt_t)TMath::Abs(v0->GetPosID());

      Double_t lMomPos[3]; //v0->GetPPxPyPz(lMomPos[0],lMomPos[1],lMomPos[2]);
      Double_t lMomNeg[3]; //v0->GetNPxPyPz(lMomNeg[0],lMomNeg[1],lMomNeg[2]);
      lMomPos[0] = v0->MomPosX();
      lMomPos[1] = v0->MomPosY();
      lMomPos[2] = v0->MomPosZ();
      lMomNeg[0] = v0->MomNegX();
      lMomNeg[1] = v0->MomNegY();
      lMomNeg[2] = v0->MomNegZ();
      
      AliAODTrack *pTrack=(AliAODTrack *)v0->GetDaughter(0); //0->Positive Daughter
      AliAODTrack *nTrack=(AliAODTrack *)v0->GetDaughter(1); //1->Negative Daughter
      if (!pTrack || !nTrack) {
	AliError("ERROR: Could not retreive one of the daughter track");
	continue;
      }

      //Daughter Eta for Eta selection, afterwards
      Double_t lNegEta = nTrack->Eta();
      Double_t lPosEta = pTrack->Eta();
      
      // Filter like-sign V0 (next: add counter and distribution)
      if ( pTrack->Charge() == nTrack->Charge()){
	continue;
      } 
      
      //Quick test this far! 
      

      //________________________________________________________________________
      // Track quality cuts 
      Float_t lPosTrackCrossedRows = pTrack->GetTPCClusterInfo(2,1);
      Float_t lNegTrackCrossedRows = nTrack->GetTPCClusterInfo(2,1);
      Float_t lLeastNbrCrossedRows =  (lPosTrackCrossedRows>lNegTrackCrossedRows) ? lNegTrackCrossedRows : lPosTrackCrossedRows;

      // TPC refit condition (done during reconstruction for Offline but not for On-the-fly)
      if( !(pTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue;
      if( !(nTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue;
      
      if ( ( ( pTrack->GetTPCClusterInfo(2,1) ) < 70 ) || ( ( nTrack->GetTPCClusterInfo(2,1) ) < 70 ) ) continue;
      
      //Findable clusters > 0 condition
      if( pTrack->GetTPCNclsF()<=0 || nTrack->GetTPCNclsF()<=0 ) continue;
      
      //Compute ratio Crossed Rows / Findable clusters
      //Note: above test avoids division by zero! 
      Float_t lPosTrackCrossedRowsOverFindable = lPosTrackCrossedRows / ((double)(pTrack->GetTPCNclsF())); 
      Float_t lNegTrackCrossedRowsOverFindable = lNegTrackCrossedRows / ((double)(nTrack->GetTPCNclsF())); 
      Float_t lLeastNbrCrossedRowsOverFindable = (lPosTrackCrossedRowsOverFindable>lNegTrackCrossedRowsOverFindable) ? lNegTrackCrossedRowsOverFindable : lPosTrackCrossedRowsOverFindable;

      //Lowest Cut Level for Ratio Crossed Rows / Findable = 0.8, set here
      if ( lLeastNbrCrossedRowsOverFindable < 0.8) continue;
      
      //End track Quality Cuts
      //________________________________________________________________________
      
      
      lDcaPosToPrimVertex = v0->DcaPosToPrimVertex();
      lDcaNegToPrimVertex = v0->DcaNegToPrimVertex();
          
      lOnFlyStatus = v0->GetOnFlyStatus();
      lChi2V0 = v0->Chi2V0();
      lDcaV0Daughters = v0->DcaV0Daughters();
      lDcaV0ToPrimVertex = v0->DcaV0ToPrimVertex();
      lV0CosineOfPointingAngle = v0->CosPointingAngle(tPrimaryVtxPosition);
      
      // Distance over total momentum
      Double_t lDistOverTotMom = TMath::Sqrt(
				    TMath::Power( tDecayVertexV0[0] - tPrimaryVtxPosition[0] , 2) +
				    TMath::Power( tDecayVertexV0[1] - tPrimaryVtxPosition[1] , 2) +
				    TMath::Power( tDecayVertexV0[2] - tPrimaryVtxPosition[2] , 2)
				    );
      lDistOverTotMom /= (lV0TotalMomentum+1e-10); //avoid division by zero, to be sure
      
      
      // Getting invariant mass infos directly from ESD
      lInvMassK0s        = v0->MassK0Short();
      lInvMassLambda     = v0->MassLambda();
      lInvMassAntiLambda = v0->MassAntiLambda();
      lAlphaV0 = v0->AlphaV0();
      lPtArmV0 = v0->PtArmV0();

      //Official means of acquiring N-sigmas 
      Double_t lNSigmasPosProton = fPIDResponse->NumberOfSigmasTPC( pTrack, AliPID::kProton );
      Double_t lNSigmasPosPion   = fPIDResponse->NumberOfSigmasTPC( pTrack, AliPID::kPion );
      Double_t lNSigmasNegProton = fPIDResponse->NumberOfSigmasTPC( nTrack, AliPID::kProton );
      Double_t lNSigmasNegPion   = fPIDResponse->NumberOfSigmasTPC( nTrack, AliPID::kPion );

      //V0 QA histograms (before V0 selection)
      fHistV0InvMassK0->Fill(lInvMassK0s);
      fHistV0InvMassLambda->Fill(lInvMassLambda);
      fHistV0InvMassAntiLambda->Fill(lInvMassAntiLambda);
      fHistV0Armenteros->Fill(lAlphaV0,lPtArmV0);
      
      
      //First Selection: Reject OnFly
      if( (lOnFlyStatus == 0 && fkUseOnTheFly == kFALSE) || (lOnFlyStatus != 0 && fkUseOnTheFly == kTRUE ) ){
	

      	//Second Selection: rough 20-sigma band, parametric. 	
      	//K0Short: Enough to parametrize peak broadening with linear function.    
      	Double_t lUpperLimitK0Short = (5.63707e-01) + (1.14979e-02)*lPt; 
      	Double_t lLowerLimitK0Short = (4.30006e-01) - (1.10029e-02)*lPt;
	
      	//Lambda: Linear (for higher pt) plus exponential (for low-pt broadening)
      	//[0]+[1]*x+[2]*TMath::Exp(-[3]*x)
      	Double_t lUpperLimitLambda = (1.13688e+00) + (5.27838e-03)*lPt + (8.42220e-02)*TMath::Exp(-(3.80595e+00)*lPt); 
      	Double_t lLowerLimitLambda = (1.09501e+00) - (5.23272e-03)*lPt - (7.52690e-02)*TMath::Exp(-(3.46339e+00)*lPt);
	
      	//Do Selection      
      	if( (lInvMassLambda     < lUpperLimitLambda  && lInvMassLambda     > lLowerLimitLambda     ) || 
      	    (lInvMassAntiLambda < lUpperLimitLambda  && lInvMassAntiLambda > lLowerLimitLambda     ) || 
      	    (lInvMassK0s        < lUpperLimitK0Short && lInvMassK0s        > lLowerLimitK0Short    ) ){


      // 	  //Pre-selection in case this is AA...
      // 	  //if( fkIsNuclear == kFALSE ) fTree->Fill();
      // 	  //if( fkIsNuclear == kTRUE){ 
      // 	  //If this is a nuclear collision___________________
      // 	  // ... pre-filter with TPC, daughter eta selection

	  
	  if( (lInvMassLambda     < lUpperLimitLambda  && lInvMassLambda     > lLowerLimitLambda 
      	       && TMath::Abs(lNSigmasPosProton) < 6.0 && TMath::Abs(lNSigmasNegPion) < 6.0 ) || 
      	      (lInvMassAntiLambda < lUpperLimitLambda  && lInvMassAntiLambda > lLowerLimitLambda 
      	       && TMath::Abs(lNSigmasNegProton) < 6.0 && TMath::Abs(lNSigmasPosPion) < 6.0 ) ||  
      	      (lInvMassK0s        < lUpperLimitK0Short && lInvMassK0s        > lLowerLimitK0Short 
      	       && TMath::Abs(lNSigmasNegPion)   < 6.0 && TMath::Abs(lNSigmasPosPion) < 6.0 ) ){
	    
      	    //insane test
      	    if ( TMath::Abs(lNegEta)<0.8 && TMath::Abs(lPosEta)<0.8 ){

	      // start the fine selection (usually done in post processing, but we don't have time to waste) --> Lambdas!
	      if(
		 TMath::Abs(lRap)<fRapidityBoundary &&
		 TMath::Abs(lNegEta)       <= fCutDaughterEta               &&                   
		 TMath::Abs(lPosEta)       <= fCutDaughterEta               &&
		 lV0Radius                 >= fCutV0Radius                  &&
		 lDcaNegToPrimVertex       >= fCutDCANegToPV                &&
		 lDcaPosToPrimVertex       >= fCutDCAPosToPV                &&
		 lDcaV0Daughters           <= fCutDCAV0Daughters            &&
		 lV0CosineOfPointingAngle  >= fCutV0CosPA                   && 
		 fMassLambda*lDistOverTotMom    <= fCutProperLifetime       &&
		 lLeastNbrCrossedRows             >= fCutLeastNumberOfCrossedRows             &&
		 lLeastNbrCrossedRowsOverFindable >= fCutLeastNumberOfCrossedRowsOverFindable &&
		 lPtArmV0 * 5 < TMath::Abs(lAlphaV0)                        && 
		 ((TMath::Abs(lNSigmasNegPion)   <= fCutTPCPIDNSigmasPion     &&
		  TMath::Abs(lNSigmasPosProton) <= fCutTPCPIDNSigmasProton) ||
		  (TMath::Abs(lNSigmasPosPion)   <= fCutTPCPIDNSigmasPion     &&
		   TMath::Abs(lNSigmasNegProton) <= fCutTPCPIDNSigmasProton)) 		 
		 )
		{

		  //V0 QA histograms (after V0 selection)
		  fHistV0SelInvMassK0->Fill(lInvMassK0s);
		  fHistV0SelInvMassLambda->Fill(lInvMassLambda);
		  fHistV0SelInvMassAntiLambda->Fill(lInvMassAntiLambda);

		  // this means a V0 candidate is found
		  if(TMath::Abs(lInvMassLambda-fMassLambda) < fCutMassLambda ||
		     TMath::Abs(lInvMassAntiLambda-fMassLambda) < fCutMassLambda){

		    fHistV0SelArmenteros->Fill(lAlphaV0,lPtArmV0);		  

		    vEta    = lEta;
		    vPhi    = lPhi;
		    vPt     = lPt;
		    if(lAlphaV0 > 0) vCharge = 1;
		    if(lAlphaV0 < 0) vCharge = -1;

		    // fill QA histograms
		    fHistPt->Fill(vPt);
		    fHistEta->Fill(vEta);
		    fHistPhi->Fill(vPhi);
		    
		    // add the track to the TObjArray
		    tracksAccepted->Add(new AliBFBasicParticle(vEta, vPhi, vPt, vCharge,1.));
		  }
		}
	      }
	  }
	  //}//end nuclear_____________________________________
	}
      }
    }//V0 loop
  
  return tracksAccepted;
}

//________________________________________________________________________
TObjArray* AliAnalysisTaskTriggeredBF::GetShuffledTracks(TObjArray *tracks){
  // 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);
    tracksShuffled->Add(new AliBFBasicParticle(track->Eta(), track->Phi(), track->Pt(),chargeVector->at(i),1.));
  }

  delete chargeVector;
   
  return tracksShuffled;
}

//________________________________________________________________________
void  AliAnalysisTaskTriggeredBF::FinishTaskOutput(){
  //checks if Balance Function objects are there (needed to write the histograms)
  if (!fBalance) {
    AliError("fBalance not available");
    return;
  }  
  if(fRunShuffling) {
    if (!fShuffledBalance) {
      AliError("fShuffledBalance not available");
      return;
    }
  }

}

//________________________________________________________________________
void AliAnalysisTaskTriggeredBF::Terminate(Option_t *) {
  // Called once at the end of the query

  // not implemented ...

}

void AliAnalysisTaskTriggeredBF::UserExecMix(Option_t *)
{

  // not yet done for event mixing!
  return;

}

 AliAnalysisTaskTriggeredBF.cxx:1
 AliAnalysisTaskTriggeredBF.cxx:2
 AliAnalysisTaskTriggeredBF.cxx:3
 AliAnalysisTaskTriggeredBF.cxx:4
 AliAnalysisTaskTriggeredBF.cxx:5
 AliAnalysisTaskTriggeredBF.cxx:6
 AliAnalysisTaskTriggeredBF.cxx:7
 AliAnalysisTaskTriggeredBF.cxx:8
 AliAnalysisTaskTriggeredBF.cxx:9
 AliAnalysisTaskTriggeredBF.cxx:10
 AliAnalysisTaskTriggeredBF.cxx:11
 AliAnalysisTaskTriggeredBF.cxx:12
 AliAnalysisTaskTriggeredBF.cxx:13
 AliAnalysisTaskTriggeredBF.cxx:14
 AliAnalysisTaskTriggeredBF.cxx:15
 AliAnalysisTaskTriggeredBF.cxx:16
 AliAnalysisTaskTriggeredBF.cxx:17
 AliAnalysisTaskTriggeredBF.cxx:18
 AliAnalysisTaskTriggeredBF.cxx:19
 AliAnalysisTaskTriggeredBF.cxx:20
 AliAnalysisTaskTriggeredBF.cxx:21
 AliAnalysisTaskTriggeredBF.cxx:22
 AliAnalysisTaskTriggeredBF.cxx:23
 AliAnalysisTaskTriggeredBF.cxx:24
 AliAnalysisTaskTriggeredBF.cxx:25
 AliAnalysisTaskTriggeredBF.cxx:26
 AliAnalysisTaskTriggeredBF.cxx:27
 AliAnalysisTaskTriggeredBF.cxx:28
 AliAnalysisTaskTriggeredBF.cxx:29
 AliAnalysisTaskTriggeredBF.cxx:30
 AliAnalysisTaskTriggeredBF.cxx:31
 AliAnalysisTaskTriggeredBF.cxx:32
 AliAnalysisTaskTriggeredBF.cxx:33
 AliAnalysisTaskTriggeredBF.cxx:34
 AliAnalysisTaskTriggeredBF.cxx:35
 AliAnalysisTaskTriggeredBF.cxx:36
 AliAnalysisTaskTriggeredBF.cxx:37
 AliAnalysisTaskTriggeredBF.cxx:38
 AliAnalysisTaskTriggeredBF.cxx:39
 AliAnalysisTaskTriggeredBF.cxx:40
 AliAnalysisTaskTriggeredBF.cxx:41
 AliAnalysisTaskTriggeredBF.cxx:42
 AliAnalysisTaskTriggeredBF.cxx:43
 AliAnalysisTaskTriggeredBF.cxx:44
 AliAnalysisTaskTriggeredBF.cxx:45
 AliAnalysisTaskTriggeredBF.cxx:46
 AliAnalysisTaskTriggeredBF.cxx:47
 AliAnalysisTaskTriggeredBF.cxx:48
 AliAnalysisTaskTriggeredBF.cxx:49
 AliAnalysisTaskTriggeredBF.cxx:50
 AliAnalysisTaskTriggeredBF.cxx:51
 AliAnalysisTaskTriggeredBF.cxx:52
 AliAnalysisTaskTriggeredBF.cxx:53
 AliAnalysisTaskTriggeredBF.cxx:54
 AliAnalysisTaskTriggeredBF.cxx:55
 AliAnalysisTaskTriggeredBF.cxx:56
 AliAnalysisTaskTriggeredBF.cxx:57
 AliAnalysisTaskTriggeredBF.cxx:58
 AliAnalysisTaskTriggeredBF.cxx:59
 AliAnalysisTaskTriggeredBF.cxx:60
 AliAnalysisTaskTriggeredBF.cxx:61
 AliAnalysisTaskTriggeredBF.cxx:62
 AliAnalysisTaskTriggeredBF.cxx:63
 AliAnalysisTaskTriggeredBF.cxx:64
 AliAnalysisTaskTriggeredBF.cxx:65
 AliAnalysisTaskTriggeredBF.cxx:66
 AliAnalysisTaskTriggeredBF.cxx:67
 AliAnalysisTaskTriggeredBF.cxx:68
 AliAnalysisTaskTriggeredBF.cxx:69
 AliAnalysisTaskTriggeredBF.cxx:70
 AliAnalysisTaskTriggeredBF.cxx:71
 AliAnalysisTaskTriggeredBF.cxx:72
 AliAnalysisTaskTriggeredBF.cxx:73
 AliAnalysisTaskTriggeredBF.cxx:74
 AliAnalysisTaskTriggeredBF.cxx:75
 AliAnalysisTaskTriggeredBF.cxx:76
 AliAnalysisTaskTriggeredBF.cxx:77
 AliAnalysisTaskTriggeredBF.cxx:78
 AliAnalysisTaskTriggeredBF.cxx:79
 AliAnalysisTaskTriggeredBF.cxx:80
 AliAnalysisTaskTriggeredBF.cxx:81
 AliAnalysisTaskTriggeredBF.cxx:82
 AliAnalysisTaskTriggeredBF.cxx:83
 AliAnalysisTaskTriggeredBF.cxx:84
 AliAnalysisTaskTriggeredBF.cxx:85
 AliAnalysisTaskTriggeredBF.cxx:86
 AliAnalysisTaskTriggeredBF.cxx:87
 AliAnalysisTaskTriggeredBF.cxx:88
 AliAnalysisTaskTriggeredBF.cxx:89
 AliAnalysisTaskTriggeredBF.cxx:90
 AliAnalysisTaskTriggeredBF.cxx:91
 AliAnalysisTaskTriggeredBF.cxx:92
 AliAnalysisTaskTriggeredBF.cxx:93
 AliAnalysisTaskTriggeredBF.cxx:94
 AliAnalysisTaskTriggeredBF.cxx:95
 AliAnalysisTaskTriggeredBF.cxx:96
 AliAnalysisTaskTriggeredBF.cxx:97
 AliAnalysisTaskTriggeredBF.cxx:98
 AliAnalysisTaskTriggeredBF.cxx:99
 AliAnalysisTaskTriggeredBF.cxx:100
 AliAnalysisTaskTriggeredBF.cxx:101
 AliAnalysisTaskTriggeredBF.cxx:102
 AliAnalysisTaskTriggeredBF.cxx:103
 AliAnalysisTaskTriggeredBF.cxx:104
 AliAnalysisTaskTriggeredBF.cxx:105
 AliAnalysisTaskTriggeredBF.cxx:106
 AliAnalysisTaskTriggeredBF.cxx:107
 AliAnalysisTaskTriggeredBF.cxx:108
 AliAnalysisTaskTriggeredBF.cxx:109
 AliAnalysisTaskTriggeredBF.cxx:110
 AliAnalysisTaskTriggeredBF.cxx:111
 AliAnalysisTaskTriggeredBF.cxx:112
 AliAnalysisTaskTriggeredBF.cxx:113
 AliAnalysisTaskTriggeredBF.cxx:114
 AliAnalysisTaskTriggeredBF.cxx:115
 AliAnalysisTaskTriggeredBF.cxx:116
 AliAnalysisTaskTriggeredBF.cxx:117
 AliAnalysisTaskTriggeredBF.cxx:118
 AliAnalysisTaskTriggeredBF.cxx:119
 AliAnalysisTaskTriggeredBF.cxx:120
 AliAnalysisTaskTriggeredBF.cxx:121
 AliAnalysisTaskTriggeredBF.cxx:122
 AliAnalysisTaskTriggeredBF.cxx:123
 AliAnalysisTaskTriggeredBF.cxx:124
 AliAnalysisTaskTriggeredBF.cxx:125
 AliAnalysisTaskTriggeredBF.cxx:126
 AliAnalysisTaskTriggeredBF.cxx:127
 AliAnalysisTaskTriggeredBF.cxx:128
 AliAnalysisTaskTriggeredBF.cxx:129
 AliAnalysisTaskTriggeredBF.cxx:130
 AliAnalysisTaskTriggeredBF.cxx:131
 AliAnalysisTaskTriggeredBF.cxx:132
 AliAnalysisTaskTriggeredBF.cxx:133
 AliAnalysisTaskTriggeredBF.cxx:134
 AliAnalysisTaskTriggeredBF.cxx:135
 AliAnalysisTaskTriggeredBF.cxx:136
 AliAnalysisTaskTriggeredBF.cxx:137
 AliAnalysisTaskTriggeredBF.cxx:138
 AliAnalysisTaskTriggeredBF.cxx:139
 AliAnalysisTaskTriggeredBF.cxx:140
 AliAnalysisTaskTriggeredBF.cxx:141
 AliAnalysisTaskTriggeredBF.cxx:142
 AliAnalysisTaskTriggeredBF.cxx:143
 AliAnalysisTaskTriggeredBF.cxx:144
 AliAnalysisTaskTriggeredBF.cxx:145
 AliAnalysisTaskTriggeredBF.cxx:146
 AliAnalysisTaskTriggeredBF.cxx:147
 AliAnalysisTaskTriggeredBF.cxx:148
 AliAnalysisTaskTriggeredBF.cxx:149
 AliAnalysisTaskTriggeredBF.cxx:150
 AliAnalysisTaskTriggeredBF.cxx:151
 AliAnalysisTaskTriggeredBF.cxx:152
 AliAnalysisTaskTriggeredBF.cxx:153
 AliAnalysisTaskTriggeredBF.cxx:154
 AliAnalysisTaskTriggeredBF.cxx:155
 AliAnalysisTaskTriggeredBF.cxx:156
 AliAnalysisTaskTriggeredBF.cxx:157
 AliAnalysisTaskTriggeredBF.cxx:158
 AliAnalysisTaskTriggeredBF.cxx:159
 AliAnalysisTaskTriggeredBF.cxx:160
 AliAnalysisTaskTriggeredBF.cxx:161
 AliAnalysisTaskTriggeredBF.cxx:162
 AliAnalysisTaskTriggeredBF.cxx:163
 AliAnalysisTaskTriggeredBF.cxx:164
 AliAnalysisTaskTriggeredBF.cxx:165
 AliAnalysisTaskTriggeredBF.cxx:166
 AliAnalysisTaskTriggeredBF.cxx:167
 AliAnalysisTaskTriggeredBF.cxx:168
 AliAnalysisTaskTriggeredBF.cxx:169
 AliAnalysisTaskTriggeredBF.cxx:170
 AliAnalysisTaskTriggeredBF.cxx:171
 AliAnalysisTaskTriggeredBF.cxx:172
 AliAnalysisTaskTriggeredBF.cxx:173
 AliAnalysisTaskTriggeredBF.cxx:174
 AliAnalysisTaskTriggeredBF.cxx:175
 AliAnalysisTaskTriggeredBF.cxx:176
 AliAnalysisTaskTriggeredBF.cxx:177
 AliAnalysisTaskTriggeredBF.cxx:178
 AliAnalysisTaskTriggeredBF.cxx:179
 AliAnalysisTaskTriggeredBF.cxx:180
 AliAnalysisTaskTriggeredBF.cxx:181
 AliAnalysisTaskTriggeredBF.cxx:182
 AliAnalysisTaskTriggeredBF.cxx:183
 AliAnalysisTaskTriggeredBF.cxx:184
 AliAnalysisTaskTriggeredBF.cxx:185
 AliAnalysisTaskTriggeredBF.cxx:186
 AliAnalysisTaskTriggeredBF.cxx:187
 AliAnalysisTaskTriggeredBF.cxx:188
 AliAnalysisTaskTriggeredBF.cxx:189
 AliAnalysisTaskTriggeredBF.cxx:190
 AliAnalysisTaskTriggeredBF.cxx:191
 AliAnalysisTaskTriggeredBF.cxx:192
 AliAnalysisTaskTriggeredBF.cxx:193
 AliAnalysisTaskTriggeredBF.cxx:194
 AliAnalysisTaskTriggeredBF.cxx:195
 AliAnalysisTaskTriggeredBF.cxx:196
 AliAnalysisTaskTriggeredBF.cxx:197
 AliAnalysisTaskTriggeredBF.cxx:198
 AliAnalysisTaskTriggeredBF.cxx:199
 AliAnalysisTaskTriggeredBF.cxx:200
 AliAnalysisTaskTriggeredBF.cxx:201
 AliAnalysisTaskTriggeredBF.cxx:202
 AliAnalysisTaskTriggeredBF.cxx:203
 AliAnalysisTaskTriggeredBF.cxx:204
 AliAnalysisTaskTriggeredBF.cxx:205
 AliAnalysisTaskTriggeredBF.cxx:206
 AliAnalysisTaskTriggeredBF.cxx:207
 AliAnalysisTaskTriggeredBF.cxx:208
 AliAnalysisTaskTriggeredBF.cxx:209
 AliAnalysisTaskTriggeredBF.cxx:210
 AliAnalysisTaskTriggeredBF.cxx:211
 AliAnalysisTaskTriggeredBF.cxx:212
 AliAnalysisTaskTriggeredBF.cxx:213
 AliAnalysisTaskTriggeredBF.cxx:214
 AliAnalysisTaskTriggeredBF.cxx:215
 AliAnalysisTaskTriggeredBF.cxx:216
 AliAnalysisTaskTriggeredBF.cxx:217
 AliAnalysisTaskTriggeredBF.cxx:218
 AliAnalysisTaskTriggeredBF.cxx:219
 AliAnalysisTaskTriggeredBF.cxx:220
 AliAnalysisTaskTriggeredBF.cxx:221
 AliAnalysisTaskTriggeredBF.cxx:222
 AliAnalysisTaskTriggeredBF.cxx:223
 AliAnalysisTaskTriggeredBF.cxx:224
 AliAnalysisTaskTriggeredBF.cxx:225
 AliAnalysisTaskTriggeredBF.cxx:226
 AliAnalysisTaskTriggeredBF.cxx:227
 AliAnalysisTaskTriggeredBF.cxx:228
 AliAnalysisTaskTriggeredBF.cxx:229
 AliAnalysisTaskTriggeredBF.cxx:230
 AliAnalysisTaskTriggeredBF.cxx:231
 AliAnalysisTaskTriggeredBF.cxx:232
 AliAnalysisTaskTriggeredBF.cxx:233
 AliAnalysisTaskTriggeredBF.cxx:234
 AliAnalysisTaskTriggeredBF.cxx:235
 AliAnalysisTaskTriggeredBF.cxx:236
 AliAnalysisTaskTriggeredBF.cxx:237
 AliAnalysisTaskTriggeredBF.cxx:238
 AliAnalysisTaskTriggeredBF.cxx:239
 AliAnalysisTaskTriggeredBF.cxx:240
 AliAnalysisTaskTriggeredBF.cxx:241
 AliAnalysisTaskTriggeredBF.cxx:242
 AliAnalysisTaskTriggeredBF.cxx:243
 AliAnalysisTaskTriggeredBF.cxx:244
 AliAnalysisTaskTriggeredBF.cxx:245
 AliAnalysisTaskTriggeredBF.cxx:246
 AliAnalysisTaskTriggeredBF.cxx:247
 AliAnalysisTaskTriggeredBF.cxx:248
 AliAnalysisTaskTriggeredBF.cxx:249
 AliAnalysisTaskTriggeredBF.cxx:250
 AliAnalysisTaskTriggeredBF.cxx:251
 AliAnalysisTaskTriggeredBF.cxx:252
 AliAnalysisTaskTriggeredBF.cxx:253
 AliAnalysisTaskTriggeredBF.cxx:254
 AliAnalysisTaskTriggeredBF.cxx:255
 AliAnalysisTaskTriggeredBF.cxx:256
 AliAnalysisTaskTriggeredBF.cxx:257
 AliAnalysisTaskTriggeredBF.cxx:258
 AliAnalysisTaskTriggeredBF.cxx:259
 AliAnalysisTaskTriggeredBF.cxx:260
 AliAnalysisTaskTriggeredBF.cxx:261
 AliAnalysisTaskTriggeredBF.cxx:262
 AliAnalysisTaskTriggeredBF.cxx:263
 AliAnalysisTaskTriggeredBF.cxx:264
 AliAnalysisTaskTriggeredBF.cxx:265
 AliAnalysisTaskTriggeredBF.cxx:266
 AliAnalysisTaskTriggeredBF.cxx:267
 AliAnalysisTaskTriggeredBF.cxx:268
 AliAnalysisTaskTriggeredBF.cxx:269
 AliAnalysisTaskTriggeredBF.cxx:270
 AliAnalysisTaskTriggeredBF.cxx:271
 AliAnalysisTaskTriggeredBF.cxx:272
 AliAnalysisTaskTriggeredBF.cxx:273
 AliAnalysisTaskTriggeredBF.cxx:274
 AliAnalysisTaskTriggeredBF.cxx:275
 AliAnalysisTaskTriggeredBF.cxx:276
 AliAnalysisTaskTriggeredBF.cxx:277
 AliAnalysisTaskTriggeredBF.cxx:278
 AliAnalysisTaskTriggeredBF.cxx:279
 AliAnalysisTaskTriggeredBF.cxx:280
 AliAnalysisTaskTriggeredBF.cxx:281
 AliAnalysisTaskTriggeredBF.cxx:282
 AliAnalysisTaskTriggeredBF.cxx:283
 AliAnalysisTaskTriggeredBF.cxx:284
 AliAnalysisTaskTriggeredBF.cxx:285
 AliAnalysisTaskTriggeredBF.cxx:286
 AliAnalysisTaskTriggeredBF.cxx:287
 AliAnalysisTaskTriggeredBF.cxx:288
 AliAnalysisTaskTriggeredBF.cxx:289
 AliAnalysisTaskTriggeredBF.cxx:290
 AliAnalysisTaskTriggeredBF.cxx:291
 AliAnalysisTaskTriggeredBF.cxx:292
 AliAnalysisTaskTriggeredBF.cxx:293
 AliAnalysisTaskTriggeredBF.cxx:294
 AliAnalysisTaskTriggeredBF.cxx:295
 AliAnalysisTaskTriggeredBF.cxx:296
 AliAnalysisTaskTriggeredBF.cxx:297
 AliAnalysisTaskTriggeredBF.cxx:298
 AliAnalysisTaskTriggeredBF.cxx:299
 AliAnalysisTaskTriggeredBF.cxx:300
 AliAnalysisTaskTriggeredBF.cxx:301
 AliAnalysisTaskTriggeredBF.cxx:302
 AliAnalysisTaskTriggeredBF.cxx:303
 AliAnalysisTaskTriggeredBF.cxx:304
 AliAnalysisTaskTriggeredBF.cxx:305
 AliAnalysisTaskTriggeredBF.cxx:306
 AliAnalysisTaskTriggeredBF.cxx:307
 AliAnalysisTaskTriggeredBF.cxx:308
 AliAnalysisTaskTriggeredBF.cxx:309
 AliAnalysisTaskTriggeredBF.cxx:310
 AliAnalysisTaskTriggeredBF.cxx:311
 AliAnalysisTaskTriggeredBF.cxx:312
 AliAnalysisTaskTriggeredBF.cxx:313
 AliAnalysisTaskTriggeredBF.cxx:314
 AliAnalysisTaskTriggeredBF.cxx:315
 AliAnalysisTaskTriggeredBF.cxx:316
 AliAnalysisTaskTriggeredBF.cxx:317
 AliAnalysisTaskTriggeredBF.cxx:318
 AliAnalysisTaskTriggeredBF.cxx:319
 AliAnalysisTaskTriggeredBF.cxx:320
 AliAnalysisTaskTriggeredBF.cxx:321
 AliAnalysisTaskTriggeredBF.cxx:322
 AliAnalysisTaskTriggeredBF.cxx:323
 AliAnalysisTaskTriggeredBF.cxx:324
 AliAnalysisTaskTriggeredBF.cxx:325
 AliAnalysisTaskTriggeredBF.cxx:326
 AliAnalysisTaskTriggeredBF.cxx:327
 AliAnalysisTaskTriggeredBF.cxx:328
 AliAnalysisTaskTriggeredBF.cxx:329
 AliAnalysisTaskTriggeredBF.cxx:330
 AliAnalysisTaskTriggeredBF.cxx:331
 AliAnalysisTaskTriggeredBF.cxx:332
 AliAnalysisTaskTriggeredBF.cxx:333
 AliAnalysisTaskTriggeredBF.cxx:334
 AliAnalysisTaskTriggeredBF.cxx:335
 AliAnalysisTaskTriggeredBF.cxx:336
 AliAnalysisTaskTriggeredBF.cxx:337
 AliAnalysisTaskTriggeredBF.cxx:338
 AliAnalysisTaskTriggeredBF.cxx:339
 AliAnalysisTaskTriggeredBF.cxx:340
 AliAnalysisTaskTriggeredBF.cxx:341
 AliAnalysisTaskTriggeredBF.cxx:342
 AliAnalysisTaskTriggeredBF.cxx:343
 AliAnalysisTaskTriggeredBF.cxx:344
 AliAnalysisTaskTriggeredBF.cxx:345
 AliAnalysisTaskTriggeredBF.cxx:346
 AliAnalysisTaskTriggeredBF.cxx:347
 AliAnalysisTaskTriggeredBF.cxx:348
 AliAnalysisTaskTriggeredBF.cxx:349
 AliAnalysisTaskTriggeredBF.cxx:350
 AliAnalysisTaskTriggeredBF.cxx:351
 AliAnalysisTaskTriggeredBF.cxx:352
 AliAnalysisTaskTriggeredBF.cxx:353
 AliAnalysisTaskTriggeredBF.cxx:354
 AliAnalysisTaskTriggeredBF.cxx:355
 AliAnalysisTaskTriggeredBF.cxx:356
 AliAnalysisTaskTriggeredBF.cxx:357
 AliAnalysisTaskTriggeredBF.cxx:358
 AliAnalysisTaskTriggeredBF.cxx:359
 AliAnalysisTaskTriggeredBF.cxx:360
 AliAnalysisTaskTriggeredBF.cxx:361
 AliAnalysisTaskTriggeredBF.cxx:362
 AliAnalysisTaskTriggeredBF.cxx:363
 AliAnalysisTaskTriggeredBF.cxx:364
 AliAnalysisTaskTriggeredBF.cxx:365
 AliAnalysisTaskTriggeredBF.cxx:366
 AliAnalysisTaskTriggeredBF.cxx:367
 AliAnalysisTaskTriggeredBF.cxx:368
 AliAnalysisTaskTriggeredBF.cxx:369
 AliAnalysisTaskTriggeredBF.cxx:370
 AliAnalysisTaskTriggeredBF.cxx:371
 AliAnalysisTaskTriggeredBF.cxx:372
 AliAnalysisTaskTriggeredBF.cxx:373
 AliAnalysisTaskTriggeredBF.cxx:374
 AliAnalysisTaskTriggeredBF.cxx:375
 AliAnalysisTaskTriggeredBF.cxx:376
 AliAnalysisTaskTriggeredBF.cxx:377
 AliAnalysisTaskTriggeredBF.cxx:378
 AliAnalysisTaskTriggeredBF.cxx:379
 AliAnalysisTaskTriggeredBF.cxx:380
 AliAnalysisTaskTriggeredBF.cxx:381
 AliAnalysisTaskTriggeredBF.cxx:382
 AliAnalysisTaskTriggeredBF.cxx:383
 AliAnalysisTaskTriggeredBF.cxx:384
 AliAnalysisTaskTriggeredBF.cxx:385
 AliAnalysisTaskTriggeredBF.cxx:386
 AliAnalysisTaskTriggeredBF.cxx:387
 AliAnalysisTaskTriggeredBF.cxx:388
 AliAnalysisTaskTriggeredBF.cxx:389
 AliAnalysisTaskTriggeredBF.cxx:390
 AliAnalysisTaskTriggeredBF.cxx:391
 AliAnalysisTaskTriggeredBF.cxx:392
 AliAnalysisTaskTriggeredBF.cxx:393
 AliAnalysisTaskTriggeredBF.cxx:394
 AliAnalysisTaskTriggeredBF.cxx:395
 AliAnalysisTaskTriggeredBF.cxx:396
 AliAnalysisTaskTriggeredBF.cxx:397
 AliAnalysisTaskTriggeredBF.cxx:398
 AliAnalysisTaskTriggeredBF.cxx:399
 AliAnalysisTaskTriggeredBF.cxx:400
 AliAnalysisTaskTriggeredBF.cxx:401
 AliAnalysisTaskTriggeredBF.cxx:402
 AliAnalysisTaskTriggeredBF.cxx:403
 AliAnalysisTaskTriggeredBF.cxx:404
 AliAnalysisTaskTriggeredBF.cxx:405
 AliAnalysisTaskTriggeredBF.cxx:406
 AliAnalysisTaskTriggeredBF.cxx:407
 AliAnalysisTaskTriggeredBF.cxx:408
 AliAnalysisTaskTriggeredBF.cxx:409
 AliAnalysisTaskTriggeredBF.cxx:410
 AliAnalysisTaskTriggeredBF.cxx:411
 AliAnalysisTaskTriggeredBF.cxx:412
 AliAnalysisTaskTriggeredBF.cxx:413
 AliAnalysisTaskTriggeredBF.cxx:414
 AliAnalysisTaskTriggeredBF.cxx:415
 AliAnalysisTaskTriggeredBF.cxx:416
 AliAnalysisTaskTriggeredBF.cxx:417
 AliAnalysisTaskTriggeredBF.cxx:418
 AliAnalysisTaskTriggeredBF.cxx:419
 AliAnalysisTaskTriggeredBF.cxx:420
 AliAnalysisTaskTriggeredBF.cxx:421
 AliAnalysisTaskTriggeredBF.cxx:422
 AliAnalysisTaskTriggeredBF.cxx:423
 AliAnalysisTaskTriggeredBF.cxx:424
 AliAnalysisTaskTriggeredBF.cxx:425
 AliAnalysisTaskTriggeredBF.cxx:426
 AliAnalysisTaskTriggeredBF.cxx:427
 AliAnalysisTaskTriggeredBF.cxx:428
 AliAnalysisTaskTriggeredBF.cxx:429
 AliAnalysisTaskTriggeredBF.cxx:430
 AliAnalysisTaskTriggeredBF.cxx:431
 AliAnalysisTaskTriggeredBF.cxx:432
 AliAnalysisTaskTriggeredBF.cxx:433
 AliAnalysisTaskTriggeredBF.cxx:434
 AliAnalysisTaskTriggeredBF.cxx:435
 AliAnalysisTaskTriggeredBF.cxx:436
 AliAnalysisTaskTriggeredBF.cxx:437
 AliAnalysisTaskTriggeredBF.cxx:438
 AliAnalysisTaskTriggeredBF.cxx:439
 AliAnalysisTaskTriggeredBF.cxx:440
 AliAnalysisTaskTriggeredBF.cxx:441
 AliAnalysisTaskTriggeredBF.cxx:442
 AliAnalysisTaskTriggeredBF.cxx:443
 AliAnalysisTaskTriggeredBF.cxx:444
 AliAnalysisTaskTriggeredBF.cxx:445
 AliAnalysisTaskTriggeredBF.cxx:446
 AliAnalysisTaskTriggeredBF.cxx:447
 AliAnalysisTaskTriggeredBF.cxx:448
 AliAnalysisTaskTriggeredBF.cxx:449
 AliAnalysisTaskTriggeredBF.cxx:450
 AliAnalysisTaskTriggeredBF.cxx:451
 AliAnalysisTaskTriggeredBF.cxx:452
 AliAnalysisTaskTriggeredBF.cxx:453
 AliAnalysisTaskTriggeredBF.cxx:454
 AliAnalysisTaskTriggeredBF.cxx:455
 AliAnalysisTaskTriggeredBF.cxx:456
 AliAnalysisTaskTriggeredBF.cxx:457
 AliAnalysisTaskTriggeredBF.cxx:458
 AliAnalysisTaskTriggeredBF.cxx:459
 AliAnalysisTaskTriggeredBF.cxx:460
 AliAnalysisTaskTriggeredBF.cxx:461
 AliAnalysisTaskTriggeredBF.cxx:462
 AliAnalysisTaskTriggeredBF.cxx:463
 AliAnalysisTaskTriggeredBF.cxx:464
 AliAnalysisTaskTriggeredBF.cxx:465
 AliAnalysisTaskTriggeredBF.cxx:466
 AliAnalysisTaskTriggeredBF.cxx:467
 AliAnalysisTaskTriggeredBF.cxx:468
 AliAnalysisTaskTriggeredBF.cxx:469
 AliAnalysisTaskTriggeredBF.cxx:470
 AliAnalysisTaskTriggeredBF.cxx:471
 AliAnalysisTaskTriggeredBF.cxx:472
 AliAnalysisTaskTriggeredBF.cxx:473
 AliAnalysisTaskTriggeredBF.cxx:474
 AliAnalysisTaskTriggeredBF.cxx:475
 AliAnalysisTaskTriggeredBF.cxx:476
 AliAnalysisTaskTriggeredBF.cxx:477
 AliAnalysisTaskTriggeredBF.cxx:478
 AliAnalysisTaskTriggeredBF.cxx:479
 AliAnalysisTaskTriggeredBF.cxx:480
 AliAnalysisTaskTriggeredBF.cxx:481
 AliAnalysisTaskTriggeredBF.cxx:482
 AliAnalysisTaskTriggeredBF.cxx:483
 AliAnalysisTaskTriggeredBF.cxx:484
 AliAnalysisTaskTriggeredBF.cxx:485
 AliAnalysisTaskTriggeredBF.cxx:486
 AliAnalysisTaskTriggeredBF.cxx:487
 AliAnalysisTaskTriggeredBF.cxx:488
 AliAnalysisTaskTriggeredBF.cxx:489
 AliAnalysisTaskTriggeredBF.cxx:490
 AliAnalysisTaskTriggeredBF.cxx:491
 AliAnalysisTaskTriggeredBF.cxx:492
 AliAnalysisTaskTriggeredBF.cxx:493
 AliAnalysisTaskTriggeredBF.cxx:494
 AliAnalysisTaskTriggeredBF.cxx:495
 AliAnalysisTaskTriggeredBF.cxx:496
 AliAnalysisTaskTriggeredBF.cxx:497
 AliAnalysisTaskTriggeredBF.cxx:498
 AliAnalysisTaskTriggeredBF.cxx:499
 AliAnalysisTaskTriggeredBF.cxx:500
 AliAnalysisTaskTriggeredBF.cxx:501
 AliAnalysisTaskTriggeredBF.cxx:502
 AliAnalysisTaskTriggeredBF.cxx:503
 AliAnalysisTaskTriggeredBF.cxx:504
 AliAnalysisTaskTriggeredBF.cxx:505
 AliAnalysisTaskTriggeredBF.cxx:506
 AliAnalysisTaskTriggeredBF.cxx:507
 AliAnalysisTaskTriggeredBF.cxx:508
 AliAnalysisTaskTriggeredBF.cxx:509
 AliAnalysisTaskTriggeredBF.cxx:510
 AliAnalysisTaskTriggeredBF.cxx:511
 AliAnalysisTaskTriggeredBF.cxx:512
 AliAnalysisTaskTriggeredBF.cxx:513
 AliAnalysisTaskTriggeredBF.cxx:514
 AliAnalysisTaskTriggeredBF.cxx:515
 AliAnalysisTaskTriggeredBF.cxx:516
 AliAnalysisTaskTriggeredBF.cxx:517
 AliAnalysisTaskTriggeredBF.cxx:518
 AliAnalysisTaskTriggeredBF.cxx:519
 AliAnalysisTaskTriggeredBF.cxx:520
 AliAnalysisTaskTriggeredBF.cxx:521
 AliAnalysisTaskTriggeredBF.cxx:522
 AliAnalysisTaskTriggeredBF.cxx:523
 AliAnalysisTaskTriggeredBF.cxx:524
 AliAnalysisTaskTriggeredBF.cxx:525
 AliAnalysisTaskTriggeredBF.cxx:526
 AliAnalysisTaskTriggeredBF.cxx:527
 AliAnalysisTaskTriggeredBF.cxx:528
 AliAnalysisTaskTriggeredBF.cxx:529
 AliAnalysisTaskTriggeredBF.cxx:530
 AliAnalysisTaskTriggeredBF.cxx:531
 AliAnalysisTaskTriggeredBF.cxx:532
 AliAnalysisTaskTriggeredBF.cxx:533
 AliAnalysisTaskTriggeredBF.cxx:534
 AliAnalysisTaskTriggeredBF.cxx:535
 AliAnalysisTaskTriggeredBF.cxx:536
 AliAnalysisTaskTriggeredBF.cxx:537
 AliAnalysisTaskTriggeredBF.cxx:538
 AliAnalysisTaskTriggeredBF.cxx:539
 AliAnalysisTaskTriggeredBF.cxx:540
 AliAnalysisTaskTriggeredBF.cxx:541
 AliAnalysisTaskTriggeredBF.cxx:542
 AliAnalysisTaskTriggeredBF.cxx:543
 AliAnalysisTaskTriggeredBF.cxx:544
 AliAnalysisTaskTriggeredBF.cxx:545
 AliAnalysisTaskTriggeredBF.cxx:546
 AliAnalysisTaskTriggeredBF.cxx:547
 AliAnalysisTaskTriggeredBF.cxx:548
 AliAnalysisTaskTriggeredBF.cxx:549
 AliAnalysisTaskTriggeredBF.cxx:550
 AliAnalysisTaskTriggeredBF.cxx:551
 AliAnalysisTaskTriggeredBF.cxx:552
 AliAnalysisTaskTriggeredBF.cxx:553
 AliAnalysisTaskTriggeredBF.cxx:554
 AliAnalysisTaskTriggeredBF.cxx:555
 AliAnalysisTaskTriggeredBF.cxx:556
 AliAnalysisTaskTriggeredBF.cxx:557
 AliAnalysisTaskTriggeredBF.cxx:558
 AliAnalysisTaskTriggeredBF.cxx:559
 AliAnalysisTaskTriggeredBF.cxx:560
 AliAnalysisTaskTriggeredBF.cxx:561
 AliAnalysisTaskTriggeredBF.cxx:562
 AliAnalysisTaskTriggeredBF.cxx:563
 AliAnalysisTaskTriggeredBF.cxx:564
 AliAnalysisTaskTriggeredBF.cxx:565
 AliAnalysisTaskTriggeredBF.cxx:566
 AliAnalysisTaskTriggeredBF.cxx:567
 AliAnalysisTaskTriggeredBF.cxx:568
 AliAnalysisTaskTriggeredBF.cxx:569
 AliAnalysisTaskTriggeredBF.cxx:570
 AliAnalysisTaskTriggeredBF.cxx:571
 AliAnalysisTaskTriggeredBF.cxx:572
 AliAnalysisTaskTriggeredBF.cxx:573
 AliAnalysisTaskTriggeredBF.cxx:574
 AliAnalysisTaskTriggeredBF.cxx:575
 AliAnalysisTaskTriggeredBF.cxx:576
 AliAnalysisTaskTriggeredBF.cxx:577
 AliAnalysisTaskTriggeredBF.cxx:578
 AliAnalysisTaskTriggeredBF.cxx:579
 AliAnalysisTaskTriggeredBF.cxx:580
 AliAnalysisTaskTriggeredBF.cxx:581
 AliAnalysisTaskTriggeredBF.cxx:582
 AliAnalysisTaskTriggeredBF.cxx:583
 AliAnalysisTaskTriggeredBF.cxx:584
 AliAnalysisTaskTriggeredBF.cxx:585
 AliAnalysisTaskTriggeredBF.cxx:586
 AliAnalysisTaskTriggeredBF.cxx:587
 AliAnalysisTaskTriggeredBF.cxx:588
 AliAnalysisTaskTriggeredBF.cxx:589
 AliAnalysisTaskTriggeredBF.cxx:590
 AliAnalysisTaskTriggeredBF.cxx:591
 AliAnalysisTaskTriggeredBF.cxx:592
 AliAnalysisTaskTriggeredBF.cxx:593
 AliAnalysisTaskTriggeredBF.cxx:594
 AliAnalysisTaskTriggeredBF.cxx:595
 AliAnalysisTaskTriggeredBF.cxx:596
 AliAnalysisTaskTriggeredBF.cxx:597
 AliAnalysisTaskTriggeredBF.cxx:598
 AliAnalysisTaskTriggeredBF.cxx:599
 AliAnalysisTaskTriggeredBF.cxx:600
 AliAnalysisTaskTriggeredBF.cxx:601
 AliAnalysisTaskTriggeredBF.cxx:602
 AliAnalysisTaskTriggeredBF.cxx:603
 AliAnalysisTaskTriggeredBF.cxx:604
 AliAnalysisTaskTriggeredBF.cxx:605
 AliAnalysisTaskTriggeredBF.cxx:606
 AliAnalysisTaskTriggeredBF.cxx:607
 AliAnalysisTaskTriggeredBF.cxx:608
 AliAnalysisTaskTriggeredBF.cxx:609
 AliAnalysisTaskTriggeredBF.cxx:610
 AliAnalysisTaskTriggeredBF.cxx:611
 AliAnalysisTaskTriggeredBF.cxx:612
 AliAnalysisTaskTriggeredBF.cxx:613
 AliAnalysisTaskTriggeredBF.cxx:614
 AliAnalysisTaskTriggeredBF.cxx:615
 AliAnalysisTaskTriggeredBF.cxx:616
 AliAnalysisTaskTriggeredBF.cxx:617
 AliAnalysisTaskTriggeredBF.cxx:618
 AliAnalysisTaskTriggeredBF.cxx:619
 AliAnalysisTaskTriggeredBF.cxx:620
 AliAnalysisTaskTriggeredBF.cxx:621
 AliAnalysisTaskTriggeredBF.cxx:622
 AliAnalysisTaskTriggeredBF.cxx:623
 AliAnalysisTaskTriggeredBF.cxx:624
 AliAnalysisTaskTriggeredBF.cxx:625
 AliAnalysisTaskTriggeredBF.cxx:626
 AliAnalysisTaskTriggeredBF.cxx:627
 AliAnalysisTaskTriggeredBF.cxx:628
 AliAnalysisTaskTriggeredBF.cxx:629
 AliAnalysisTaskTriggeredBF.cxx:630
 AliAnalysisTaskTriggeredBF.cxx:631
 AliAnalysisTaskTriggeredBF.cxx:632
 AliAnalysisTaskTriggeredBF.cxx:633
 AliAnalysisTaskTriggeredBF.cxx:634
 AliAnalysisTaskTriggeredBF.cxx:635
 AliAnalysisTaskTriggeredBF.cxx:636
 AliAnalysisTaskTriggeredBF.cxx:637
 AliAnalysisTaskTriggeredBF.cxx:638
 AliAnalysisTaskTriggeredBF.cxx:639
 AliAnalysisTaskTriggeredBF.cxx:640
 AliAnalysisTaskTriggeredBF.cxx:641
 AliAnalysisTaskTriggeredBF.cxx:642
 AliAnalysisTaskTriggeredBF.cxx:643
 AliAnalysisTaskTriggeredBF.cxx:644
 AliAnalysisTaskTriggeredBF.cxx:645
 AliAnalysisTaskTriggeredBF.cxx:646
 AliAnalysisTaskTriggeredBF.cxx:647
 AliAnalysisTaskTriggeredBF.cxx:648
 AliAnalysisTaskTriggeredBF.cxx:649
 AliAnalysisTaskTriggeredBF.cxx:650
 AliAnalysisTaskTriggeredBF.cxx:651
 AliAnalysisTaskTriggeredBF.cxx:652
 AliAnalysisTaskTriggeredBF.cxx:653
 AliAnalysisTaskTriggeredBF.cxx:654
 AliAnalysisTaskTriggeredBF.cxx:655
 AliAnalysisTaskTriggeredBF.cxx:656
 AliAnalysisTaskTriggeredBF.cxx:657
 AliAnalysisTaskTriggeredBF.cxx:658
 AliAnalysisTaskTriggeredBF.cxx:659
 AliAnalysisTaskTriggeredBF.cxx:660
 AliAnalysisTaskTriggeredBF.cxx:661
 AliAnalysisTaskTriggeredBF.cxx:662
 AliAnalysisTaskTriggeredBF.cxx:663
 AliAnalysisTaskTriggeredBF.cxx:664
 AliAnalysisTaskTriggeredBF.cxx:665
 AliAnalysisTaskTriggeredBF.cxx:666
 AliAnalysisTaskTriggeredBF.cxx:667
 AliAnalysisTaskTriggeredBF.cxx:668
 AliAnalysisTaskTriggeredBF.cxx:669
 AliAnalysisTaskTriggeredBF.cxx:670
 AliAnalysisTaskTriggeredBF.cxx:671
 AliAnalysisTaskTriggeredBF.cxx:672
 AliAnalysisTaskTriggeredBF.cxx:673
 AliAnalysisTaskTriggeredBF.cxx:674
 AliAnalysisTaskTriggeredBF.cxx:675
 AliAnalysisTaskTriggeredBF.cxx:676
 AliAnalysisTaskTriggeredBF.cxx:677
 AliAnalysisTaskTriggeredBF.cxx:678
 AliAnalysisTaskTriggeredBF.cxx:679
 AliAnalysisTaskTriggeredBF.cxx:680
 AliAnalysisTaskTriggeredBF.cxx:681
 AliAnalysisTaskTriggeredBF.cxx:682
 AliAnalysisTaskTriggeredBF.cxx:683
 AliAnalysisTaskTriggeredBF.cxx:684
 AliAnalysisTaskTriggeredBF.cxx:685
 AliAnalysisTaskTriggeredBF.cxx:686
 AliAnalysisTaskTriggeredBF.cxx:687
 AliAnalysisTaskTriggeredBF.cxx:688
 AliAnalysisTaskTriggeredBF.cxx:689
 AliAnalysisTaskTriggeredBF.cxx:690
 AliAnalysisTaskTriggeredBF.cxx:691
 AliAnalysisTaskTriggeredBF.cxx:692
 AliAnalysisTaskTriggeredBF.cxx:693
 AliAnalysisTaskTriggeredBF.cxx:694
 AliAnalysisTaskTriggeredBF.cxx:695
 AliAnalysisTaskTriggeredBF.cxx:696
 AliAnalysisTaskTriggeredBF.cxx:697
 AliAnalysisTaskTriggeredBF.cxx:698
 AliAnalysisTaskTriggeredBF.cxx:699
 AliAnalysisTaskTriggeredBF.cxx:700
 AliAnalysisTaskTriggeredBF.cxx:701
 AliAnalysisTaskTriggeredBF.cxx:702
 AliAnalysisTaskTriggeredBF.cxx:703
 AliAnalysisTaskTriggeredBF.cxx:704
 AliAnalysisTaskTriggeredBF.cxx:705
 AliAnalysisTaskTriggeredBF.cxx:706
 AliAnalysisTaskTriggeredBF.cxx:707
 AliAnalysisTaskTriggeredBF.cxx:708
 AliAnalysisTaskTriggeredBF.cxx:709
 AliAnalysisTaskTriggeredBF.cxx:710
 AliAnalysisTaskTriggeredBF.cxx:711
 AliAnalysisTaskTriggeredBF.cxx:712
 AliAnalysisTaskTriggeredBF.cxx:713
 AliAnalysisTaskTriggeredBF.cxx:714
 AliAnalysisTaskTriggeredBF.cxx:715
 AliAnalysisTaskTriggeredBF.cxx:716
 AliAnalysisTaskTriggeredBF.cxx:717
 AliAnalysisTaskTriggeredBF.cxx:718
 AliAnalysisTaskTriggeredBF.cxx:719
 AliAnalysisTaskTriggeredBF.cxx:720
 AliAnalysisTaskTriggeredBF.cxx:721
 AliAnalysisTaskTriggeredBF.cxx:722
 AliAnalysisTaskTriggeredBF.cxx:723
 AliAnalysisTaskTriggeredBF.cxx:724
 AliAnalysisTaskTriggeredBF.cxx:725
 AliAnalysisTaskTriggeredBF.cxx:726
 AliAnalysisTaskTriggeredBF.cxx:727
 AliAnalysisTaskTriggeredBF.cxx:728
 AliAnalysisTaskTriggeredBF.cxx:729
 AliAnalysisTaskTriggeredBF.cxx:730
 AliAnalysisTaskTriggeredBF.cxx:731
 AliAnalysisTaskTriggeredBF.cxx:732
 AliAnalysisTaskTriggeredBF.cxx:733
 AliAnalysisTaskTriggeredBF.cxx:734
 AliAnalysisTaskTriggeredBF.cxx:735
 AliAnalysisTaskTriggeredBF.cxx:736
 AliAnalysisTaskTriggeredBF.cxx:737
 AliAnalysisTaskTriggeredBF.cxx:738
 AliAnalysisTaskTriggeredBF.cxx:739
 AliAnalysisTaskTriggeredBF.cxx:740
 AliAnalysisTaskTriggeredBF.cxx:741
 AliAnalysisTaskTriggeredBF.cxx:742
 AliAnalysisTaskTriggeredBF.cxx:743
 AliAnalysisTaskTriggeredBF.cxx:744
 AliAnalysisTaskTriggeredBF.cxx:745
 AliAnalysisTaskTriggeredBF.cxx:746
 AliAnalysisTaskTriggeredBF.cxx:747
 AliAnalysisTaskTriggeredBF.cxx:748
 AliAnalysisTaskTriggeredBF.cxx:749
 AliAnalysisTaskTriggeredBF.cxx:750
 AliAnalysisTaskTriggeredBF.cxx:751
 AliAnalysisTaskTriggeredBF.cxx:752
 AliAnalysisTaskTriggeredBF.cxx:753
 AliAnalysisTaskTriggeredBF.cxx:754
 AliAnalysisTaskTriggeredBF.cxx:755
 AliAnalysisTaskTriggeredBF.cxx:756
 AliAnalysisTaskTriggeredBF.cxx:757
 AliAnalysisTaskTriggeredBF.cxx:758
 AliAnalysisTaskTriggeredBF.cxx:759
 AliAnalysisTaskTriggeredBF.cxx:760
 AliAnalysisTaskTriggeredBF.cxx:761
 AliAnalysisTaskTriggeredBF.cxx:762
 AliAnalysisTaskTriggeredBF.cxx:763
 AliAnalysisTaskTriggeredBF.cxx:764
 AliAnalysisTaskTriggeredBF.cxx:765
 AliAnalysisTaskTriggeredBF.cxx:766
 AliAnalysisTaskTriggeredBF.cxx:767
 AliAnalysisTaskTriggeredBF.cxx:768
 AliAnalysisTaskTriggeredBF.cxx:769
 AliAnalysisTaskTriggeredBF.cxx:770
 AliAnalysisTaskTriggeredBF.cxx:771
 AliAnalysisTaskTriggeredBF.cxx:772
 AliAnalysisTaskTriggeredBF.cxx:773
 AliAnalysisTaskTriggeredBF.cxx:774
 AliAnalysisTaskTriggeredBF.cxx:775
 AliAnalysisTaskTriggeredBF.cxx:776
 AliAnalysisTaskTriggeredBF.cxx:777
 AliAnalysisTaskTriggeredBF.cxx:778
 AliAnalysisTaskTriggeredBF.cxx:779
 AliAnalysisTaskTriggeredBF.cxx:780
 AliAnalysisTaskTriggeredBF.cxx:781
 AliAnalysisTaskTriggeredBF.cxx:782
 AliAnalysisTaskTriggeredBF.cxx:783
 AliAnalysisTaskTriggeredBF.cxx:784
 AliAnalysisTaskTriggeredBF.cxx:785
 AliAnalysisTaskTriggeredBF.cxx:786
 AliAnalysisTaskTriggeredBF.cxx:787
 AliAnalysisTaskTriggeredBF.cxx:788
 AliAnalysisTaskTriggeredBF.cxx:789
 AliAnalysisTaskTriggeredBF.cxx:790
 AliAnalysisTaskTriggeredBF.cxx:791
 AliAnalysisTaskTriggeredBF.cxx:792
 AliAnalysisTaskTriggeredBF.cxx:793
 AliAnalysisTaskTriggeredBF.cxx:794
 AliAnalysisTaskTriggeredBF.cxx:795
 AliAnalysisTaskTriggeredBF.cxx:796
 AliAnalysisTaskTriggeredBF.cxx:797
 AliAnalysisTaskTriggeredBF.cxx:798
 AliAnalysisTaskTriggeredBF.cxx:799
 AliAnalysisTaskTriggeredBF.cxx:800
 AliAnalysisTaskTriggeredBF.cxx:801
 AliAnalysisTaskTriggeredBF.cxx:802
 AliAnalysisTaskTriggeredBF.cxx:803
 AliAnalysisTaskTriggeredBF.cxx:804
 AliAnalysisTaskTriggeredBF.cxx:805
 AliAnalysisTaskTriggeredBF.cxx:806
 AliAnalysisTaskTriggeredBF.cxx:807
 AliAnalysisTaskTriggeredBF.cxx:808
 AliAnalysisTaskTriggeredBF.cxx:809
 AliAnalysisTaskTriggeredBF.cxx:810
 AliAnalysisTaskTriggeredBF.cxx:811
 AliAnalysisTaskTriggeredBF.cxx:812
 AliAnalysisTaskTriggeredBF.cxx:813
 AliAnalysisTaskTriggeredBF.cxx:814
 AliAnalysisTaskTriggeredBF.cxx:815
 AliAnalysisTaskTriggeredBF.cxx:816
 AliAnalysisTaskTriggeredBF.cxx:817
 AliAnalysisTaskTriggeredBF.cxx:818
 AliAnalysisTaskTriggeredBF.cxx:819
 AliAnalysisTaskTriggeredBF.cxx:820
 AliAnalysisTaskTriggeredBF.cxx:821
 AliAnalysisTaskTriggeredBF.cxx:822
 AliAnalysisTaskTriggeredBF.cxx:823
 AliAnalysisTaskTriggeredBF.cxx:824
 AliAnalysisTaskTriggeredBF.cxx:825
 AliAnalysisTaskTriggeredBF.cxx:826
 AliAnalysisTaskTriggeredBF.cxx:827
 AliAnalysisTaskTriggeredBF.cxx:828
 AliAnalysisTaskTriggeredBF.cxx:829
 AliAnalysisTaskTriggeredBF.cxx:830
 AliAnalysisTaskTriggeredBF.cxx:831
 AliAnalysisTaskTriggeredBF.cxx:832
 AliAnalysisTaskTriggeredBF.cxx:833
 AliAnalysisTaskTriggeredBF.cxx:834
 AliAnalysisTaskTriggeredBF.cxx:835
 AliAnalysisTaskTriggeredBF.cxx:836
 AliAnalysisTaskTriggeredBF.cxx:837
 AliAnalysisTaskTriggeredBF.cxx:838
 AliAnalysisTaskTriggeredBF.cxx:839
 AliAnalysisTaskTriggeredBF.cxx:840
 AliAnalysisTaskTriggeredBF.cxx:841
 AliAnalysisTaskTriggeredBF.cxx:842
 AliAnalysisTaskTriggeredBF.cxx:843
 AliAnalysisTaskTriggeredBF.cxx:844
 AliAnalysisTaskTriggeredBF.cxx:845
 AliAnalysisTaskTriggeredBF.cxx:846
 AliAnalysisTaskTriggeredBF.cxx:847
 AliAnalysisTaskTriggeredBF.cxx:848
 AliAnalysisTaskTriggeredBF.cxx:849
 AliAnalysisTaskTriggeredBF.cxx:850
 AliAnalysisTaskTriggeredBF.cxx:851
 AliAnalysisTaskTriggeredBF.cxx:852
 AliAnalysisTaskTriggeredBF.cxx:853
 AliAnalysisTaskTriggeredBF.cxx:854
 AliAnalysisTaskTriggeredBF.cxx:855
 AliAnalysisTaskTriggeredBF.cxx:856
 AliAnalysisTaskTriggeredBF.cxx:857
 AliAnalysisTaskTriggeredBF.cxx:858
 AliAnalysisTaskTriggeredBF.cxx:859
 AliAnalysisTaskTriggeredBF.cxx:860
 AliAnalysisTaskTriggeredBF.cxx:861
 AliAnalysisTaskTriggeredBF.cxx:862
 AliAnalysisTaskTriggeredBF.cxx:863
 AliAnalysisTaskTriggeredBF.cxx:864
 AliAnalysisTaskTriggeredBF.cxx:865
 AliAnalysisTaskTriggeredBF.cxx:866
 AliAnalysisTaskTriggeredBF.cxx:867
 AliAnalysisTaskTriggeredBF.cxx:868
 AliAnalysisTaskTriggeredBF.cxx:869
 AliAnalysisTaskTriggeredBF.cxx:870
 AliAnalysisTaskTriggeredBF.cxx:871
 AliAnalysisTaskTriggeredBF.cxx:872
 AliAnalysisTaskTriggeredBF.cxx:873
 AliAnalysisTaskTriggeredBF.cxx:874
 AliAnalysisTaskTriggeredBF.cxx:875
 AliAnalysisTaskTriggeredBF.cxx:876
 AliAnalysisTaskTriggeredBF.cxx:877
 AliAnalysisTaskTriggeredBF.cxx:878
 AliAnalysisTaskTriggeredBF.cxx:879
 AliAnalysisTaskTriggeredBF.cxx:880
 AliAnalysisTaskTriggeredBF.cxx:881
 AliAnalysisTaskTriggeredBF.cxx:882
 AliAnalysisTaskTriggeredBF.cxx:883
 AliAnalysisTaskTriggeredBF.cxx:884
 AliAnalysisTaskTriggeredBF.cxx:885
 AliAnalysisTaskTriggeredBF.cxx:886
 AliAnalysisTaskTriggeredBF.cxx:887
 AliAnalysisTaskTriggeredBF.cxx:888
 AliAnalysisTaskTriggeredBF.cxx:889
 AliAnalysisTaskTriggeredBF.cxx:890
 AliAnalysisTaskTriggeredBF.cxx:891
 AliAnalysisTaskTriggeredBF.cxx:892
 AliAnalysisTaskTriggeredBF.cxx:893
 AliAnalysisTaskTriggeredBF.cxx:894
 AliAnalysisTaskTriggeredBF.cxx:895
 AliAnalysisTaskTriggeredBF.cxx:896
 AliAnalysisTaskTriggeredBF.cxx:897
 AliAnalysisTaskTriggeredBF.cxx:898
 AliAnalysisTaskTriggeredBF.cxx:899
 AliAnalysisTaskTriggeredBF.cxx:900
 AliAnalysisTaskTriggeredBF.cxx:901
 AliAnalysisTaskTriggeredBF.cxx:902
 AliAnalysisTaskTriggeredBF.cxx:903
 AliAnalysisTaskTriggeredBF.cxx:904
 AliAnalysisTaskTriggeredBF.cxx:905
 AliAnalysisTaskTriggeredBF.cxx:906
 AliAnalysisTaskTriggeredBF.cxx:907
 AliAnalysisTaskTriggeredBF.cxx:908
 AliAnalysisTaskTriggeredBF.cxx:909
 AliAnalysisTaskTriggeredBF.cxx:910
 AliAnalysisTaskTriggeredBF.cxx:911
 AliAnalysisTaskTriggeredBF.cxx:912
 AliAnalysisTaskTriggeredBF.cxx:913
 AliAnalysisTaskTriggeredBF.cxx:914
 AliAnalysisTaskTriggeredBF.cxx:915
 AliAnalysisTaskTriggeredBF.cxx:916
 AliAnalysisTaskTriggeredBF.cxx:917
 AliAnalysisTaskTriggeredBF.cxx:918
 AliAnalysisTaskTriggeredBF.cxx:919
 AliAnalysisTaskTriggeredBF.cxx:920
 AliAnalysisTaskTriggeredBF.cxx:921
 AliAnalysisTaskTriggeredBF.cxx:922
 AliAnalysisTaskTriggeredBF.cxx:923
 AliAnalysisTaskTriggeredBF.cxx:924
 AliAnalysisTaskTriggeredBF.cxx:925
 AliAnalysisTaskTriggeredBF.cxx:926
 AliAnalysisTaskTriggeredBF.cxx:927
 AliAnalysisTaskTriggeredBF.cxx:928
 AliAnalysisTaskTriggeredBF.cxx:929
 AliAnalysisTaskTriggeredBF.cxx:930
 AliAnalysisTaskTriggeredBF.cxx:931
 AliAnalysisTaskTriggeredBF.cxx:932
 AliAnalysisTaskTriggeredBF.cxx:933
 AliAnalysisTaskTriggeredBF.cxx:934
 AliAnalysisTaskTriggeredBF.cxx:935
 AliAnalysisTaskTriggeredBF.cxx:936
 AliAnalysisTaskTriggeredBF.cxx:937
 AliAnalysisTaskTriggeredBF.cxx:938
 AliAnalysisTaskTriggeredBF.cxx:939
 AliAnalysisTaskTriggeredBF.cxx:940
 AliAnalysisTaskTriggeredBF.cxx:941
 AliAnalysisTaskTriggeredBF.cxx:942
 AliAnalysisTaskTriggeredBF.cxx:943
 AliAnalysisTaskTriggeredBF.cxx:944
 AliAnalysisTaskTriggeredBF.cxx:945
 AliAnalysisTaskTriggeredBF.cxx:946
 AliAnalysisTaskTriggeredBF.cxx:947
 AliAnalysisTaskTriggeredBF.cxx:948
 AliAnalysisTaskTriggeredBF.cxx:949
 AliAnalysisTaskTriggeredBF.cxx:950
 AliAnalysisTaskTriggeredBF.cxx:951
 AliAnalysisTaskTriggeredBF.cxx:952
 AliAnalysisTaskTriggeredBF.cxx:953
 AliAnalysisTaskTriggeredBF.cxx:954
 AliAnalysisTaskTriggeredBF.cxx:955
 AliAnalysisTaskTriggeredBF.cxx:956
 AliAnalysisTaskTriggeredBF.cxx:957
 AliAnalysisTaskTriggeredBF.cxx:958
 AliAnalysisTaskTriggeredBF.cxx:959
 AliAnalysisTaskTriggeredBF.cxx:960
 AliAnalysisTaskTriggeredBF.cxx:961
 AliAnalysisTaskTriggeredBF.cxx:962
 AliAnalysisTaskTriggeredBF.cxx:963
 AliAnalysisTaskTriggeredBF.cxx:964
 AliAnalysisTaskTriggeredBF.cxx:965
 AliAnalysisTaskTriggeredBF.cxx:966
 AliAnalysisTaskTriggeredBF.cxx:967
 AliAnalysisTaskTriggeredBF.cxx:968
 AliAnalysisTaskTriggeredBF.cxx:969
 AliAnalysisTaskTriggeredBF.cxx:970
 AliAnalysisTaskTriggeredBF.cxx:971
 AliAnalysisTaskTriggeredBF.cxx:972
 AliAnalysisTaskTriggeredBF.cxx:973
 AliAnalysisTaskTriggeredBF.cxx:974
 AliAnalysisTaskTriggeredBF.cxx:975
 AliAnalysisTaskTriggeredBF.cxx:976
 AliAnalysisTaskTriggeredBF.cxx:977
 AliAnalysisTaskTriggeredBF.cxx:978
 AliAnalysisTaskTriggeredBF.cxx:979
 AliAnalysisTaskTriggeredBF.cxx:980
 AliAnalysisTaskTriggeredBF.cxx:981
 AliAnalysisTaskTriggeredBF.cxx:982
 AliAnalysisTaskTriggeredBF.cxx:983
 AliAnalysisTaskTriggeredBF.cxx:984
 AliAnalysisTaskTriggeredBF.cxx:985
 AliAnalysisTaskTriggeredBF.cxx:986
 AliAnalysisTaskTriggeredBF.cxx:987
 AliAnalysisTaskTriggeredBF.cxx:988
 AliAnalysisTaskTriggeredBF.cxx:989
 AliAnalysisTaskTriggeredBF.cxx:990
 AliAnalysisTaskTriggeredBF.cxx:991
 AliAnalysisTaskTriggeredBF.cxx:992
 AliAnalysisTaskTriggeredBF.cxx:993
 AliAnalysisTaskTriggeredBF.cxx:994
 AliAnalysisTaskTriggeredBF.cxx:995
 AliAnalysisTaskTriggeredBF.cxx:996
 AliAnalysisTaskTriggeredBF.cxx:997
 AliAnalysisTaskTriggeredBF.cxx:998
 AliAnalysisTaskTriggeredBF.cxx:999
 AliAnalysisTaskTriggeredBF.cxx:1000
 AliAnalysisTaskTriggeredBF.cxx:1001
 AliAnalysisTaskTriggeredBF.cxx:1002
 AliAnalysisTaskTriggeredBF.cxx:1003
 AliAnalysisTaskTriggeredBF.cxx:1004
 AliAnalysisTaskTriggeredBF.cxx:1005
 AliAnalysisTaskTriggeredBF.cxx:1006
 AliAnalysisTaskTriggeredBF.cxx:1007
 AliAnalysisTaskTriggeredBF.cxx:1008
 AliAnalysisTaskTriggeredBF.cxx:1009
 AliAnalysisTaskTriggeredBF.cxx:1010
 AliAnalysisTaskTriggeredBF.cxx:1011
 AliAnalysisTaskTriggeredBF.cxx:1012
 AliAnalysisTaskTriggeredBF.cxx:1013
 AliAnalysisTaskTriggeredBF.cxx:1014
 AliAnalysisTaskTriggeredBF.cxx:1015
 AliAnalysisTaskTriggeredBF.cxx:1016
 AliAnalysisTaskTriggeredBF.cxx:1017
 AliAnalysisTaskTriggeredBF.cxx:1018
 AliAnalysisTaskTriggeredBF.cxx:1019
 AliAnalysisTaskTriggeredBF.cxx:1020
 AliAnalysisTaskTriggeredBF.cxx:1021
 AliAnalysisTaskTriggeredBF.cxx:1022
 AliAnalysisTaskTriggeredBF.cxx:1023
 AliAnalysisTaskTriggeredBF.cxx:1024
 AliAnalysisTaskTriggeredBF.cxx:1025
 AliAnalysisTaskTriggeredBF.cxx:1026
 AliAnalysisTaskTriggeredBF.cxx:1027
 AliAnalysisTaskTriggeredBF.cxx:1028
 AliAnalysisTaskTriggeredBF.cxx:1029
 AliAnalysisTaskTriggeredBF.cxx:1030
 AliAnalysisTaskTriggeredBF.cxx:1031
 AliAnalysisTaskTriggeredBF.cxx:1032
 AliAnalysisTaskTriggeredBF.cxx:1033
 AliAnalysisTaskTriggeredBF.cxx:1034
 AliAnalysisTaskTriggeredBF.cxx:1035
 AliAnalysisTaskTriggeredBF.cxx:1036
 AliAnalysisTaskTriggeredBF.cxx:1037
 AliAnalysisTaskTriggeredBF.cxx:1038
 AliAnalysisTaskTriggeredBF.cxx:1039
 AliAnalysisTaskTriggeredBF.cxx:1040
 AliAnalysisTaskTriggeredBF.cxx:1041
 AliAnalysisTaskTriggeredBF.cxx:1042
 AliAnalysisTaskTriggeredBF.cxx:1043
 AliAnalysisTaskTriggeredBF.cxx:1044
 AliAnalysisTaskTriggeredBF.cxx:1045
 AliAnalysisTaskTriggeredBF.cxx:1046
 AliAnalysisTaskTriggeredBF.cxx:1047
 AliAnalysisTaskTriggeredBF.cxx:1048
 AliAnalysisTaskTriggeredBF.cxx:1049
 AliAnalysisTaskTriggeredBF.cxx:1050
 AliAnalysisTaskTriggeredBF.cxx:1051
 AliAnalysisTaskTriggeredBF.cxx:1052
 AliAnalysisTaskTriggeredBF.cxx:1053
 AliAnalysisTaskTriggeredBF.cxx:1054
 AliAnalysisTaskTriggeredBF.cxx:1055
 AliAnalysisTaskTriggeredBF.cxx:1056
 AliAnalysisTaskTriggeredBF.cxx:1057
 AliAnalysisTaskTriggeredBF.cxx:1058
 AliAnalysisTaskTriggeredBF.cxx:1059
 AliAnalysisTaskTriggeredBF.cxx:1060
 AliAnalysisTaskTriggeredBF.cxx:1061
 AliAnalysisTaskTriggeredBF.cxx:1062
 AliAnalysisTaskTriggeredBF.cxx:1063
 AliAnalysisTaskTriggeredBF.cxx:1064
 AliAnalysisTaskTriggeredBF.cxx:1065
 AliAnalysisTaskTriggeredBF.cxx:1066
 AliAnalysisTaskTriggeredBF.cxx:1067
 AliAnalysisTaskTriggeredBF.cxx:1068
 AliAnalysisTaskTriggeredBF.cxx:1069
 AliAnalysisTaskTriggeredBF.cxx:1070
 AliAnalysisTaskTriggeredBF.cxx:1071
 AliAnalysisTaskTriggeredBF.cxx:1072
 AliAnalysisTaskTriggeredBF.cxx:1073
 AliAnalysisTaskTriggeredBF.cxx:1074
 AliAnalysisTaskTriggeredBF.cxx:1075
 AliAnalysisTaskTriggeredBF.cxx:1076
 AliAnalysisTaskTriggeredBF.cxx:1077
 AliAnalysisTaskTriggeredBF.cxx:1078
 AliAnalysisTaskTriggeredBF.cxx:1079
 AliAnalysisTaskTriggeredBF.cxx:1080
 AliAnalysisTaskTriggeredBF.cxx:1081
 AliAnalysisTaskTriggeredBF.cxx:1082
 AliAnalysisTaskTriggeredBF.cxx:1083
 AliAnalysisTaskTriggeredBF.cxx:1084
 AliAnalysisTaskTriggeredBF.cxx:1085
 AliAnalysisTaskTriggeredBF.cxx:1086
 AliAnalysisTaskTriggeredBF.cxx:1087
 AliAnalysisTaskTriggeredBF.cxx:1088
 AliAnalysisTaskTriggeredBF.cxx:1089
 AliAnalysisTaskTriggeredBF.cxx:1090
 AliAnalysisTaskTriggeredBF.cxx:1091
 AliAnalysisTaskTriggeredBF.cxx:1092
 AliAnalysisTaskTriggeredBF.cxx:1093
 AliAnalysisTaskTriggeredBF.cxx:1094
 AliAnalysisTaskTriggeredBF.cxx:1095
 AliAnalysisTaskTriggeredBF.cxx:1096
 AliAnalysisTaskTriggeredBF.cxx:1097
 AliAnalysisTaskTriggeredBF.cxx:1098
 AliAnalysisTaskTriggeredBF.cxx:1099
 AliAnalysisTaskTriggeredBF.cxx:1100
 AliAnalysisTaskTriggeredBF.cxx:1101
 AliAnalysisTaskTriggeredBF.cxx:1102
 AliAnalysisTaskTriggeredBF.cxx:1103
 AliAnalysisTaskTriggeredBF.cxx:1104
 AliAnalysisTaskTriggeredBF.cxx:1105
 AliAnalysisTaskTriggeredBF.cxx:1106
 AliAnalysisTaskTriggeredBF.cxx:1107
 AliAnalysisTaskTriggeredBF.cxx:1108
 AliAnalysisTaskTriggeredBF.cxx:1109
 AliAnalysisTaskTriggeredBF.cxx:1110
 AliAnalysisTaskTriggeredBF.cxx:1111
 AliAnalysisTaskTriggeredBF.cxx:1112
 AliAnalysisTaskTriggeredBF.cxx:1113
 AliAnalysisTaskTriggeredBF.cxx:1114