ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **********************************************************i****************/

/* $Id$ */ 

// AliFlowTrackCuts:
// Data selection for flow framework
//
// origin: Mikolaj Krzewicki (mikolaj.krzewicki@cern.ch)
// mods:   Redmer A. Bertens (rbertens@cern.ch)
//
// This class gurantees consistency of cut methods, trackparameter
// selection (global tracks, TPC only, etc..) and parameter mixing
// in the flow framework. Transparently handles different input types:
// ESD, MC, AOD.
// This class works in 2 steps: first the requested track parameters are
// constructed (to be set by SetParamType() ), then cuts are applied.
// the constructed track can be requested AFTER checking the cuts by
// calling GetTrack(), in this case the cut object stays in control,
// caller does not have to delete the track.
// Additionally caller can request an AliFlowTrack object to be constructed
// according the parameter mixing scenario requested by SetParamMix().
// AliFlowTrack is made using MakeFlowTrack() method, its an 'object factory'
// so caller needs to take care of the freshly created object.

#include <limits.h>
#include <float.h>
#include <TMatrix.h>
#include "TMCProcess.h"
#include "TParticle.h"
#include "TH2F.h"
#include "AliStack.h"
#include "TBrowser.h"
#include "TArrayD.h"
#include "AliMCEvent.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliVParticle.h"
#include "AliVVZERO.h"
#include "AliMCParticle.h"
#include "AliESDkink.h"
#include "AliESDv0.h"
#include "AliESDtrack.h"
#include "AliESDMuonTrack.h"   // XZhang 20120604
#include "AliMultiplicity.h"
#include "AliAODTrack.h"
#include "AliAODTracklets.h"   // XZhang 20120615
#include "AliFlowTrackSimple.h"
#include "AliFlowTrack.h"
#include "AliFlowTrackCuts.h"
#include "AliLog.h"
#include "AliESDpid.h"
#include "AliESDPmdTrack.h"
#include "AliESDUtils.h" //TODO
#include "AliFlowBayesianPID.h"
#include "AliFlowCandidateTrack.h"
#include "AliKFParticle.h"
#include "AliESDVZERO.h"
#include "AliFlowCommonConstants.h"
#include "AliAnalysisManager.h"
#include "AliPIDResponse.h"

ClassImp(AliFlowTrackCuts)

//-----------------------------------------------------------------------
AliFlowTrackCuts::AliFlowTrackCuts():
  AliFlowTrackSimpleCuts(),
  fAliESDtrackCuts(NULL),
  fMuonTrackCuts(NULL),  // XZhang 20120604
  fQA(NULL),
  fCutMC(kFALSE),
  fCutMChasTrackReferences(kFALSE),
  fCutMCprocessType(kFALSE),
  fMCprocessType(kPNoProcess),
  fCutMCPID(kFALSE),
  fMCPID(0),
  fCutMCfirstMotherPID(kFALSE),
  fMCfirstMotherPID(0),
  fIgnoreSignInMCPID(kFALSE),
  fCutMCisPrimary(kFALSE),
  fRequireTransportBitForPrimaries(kTRUE),
  fMCisPrimary(kFALSE),
  fRequireCharge(kFALSE),
  fFakesAreOK(kTRUE),
  fCutSPDtrackletDeltaPhi(kFALSE),
  fSPDtrackletDeltaPhiMax(FLT_MAX),
  fSPDtrackletDeltaPhiMin(-FLT_MAX),
  fIgnoreTPCzRange(kFALSE),
  fIgnoreTPCzRangeMax(FLT_MAX),
  fIgnoreTPCzRangeMin(-FLT_MAX),
  fCutChi2PerClusterTPC(kFALSE),
  fMaxChi2PerClusterTPC(FLT_MAX),
  fMinChi2PerClusterTPC(-FLT_MAX),
  fCutNClustersTPC(kFALSE),
  fNClustersTPCMax(INT_MAX),
  fNClustersTPCMin(INT_MIN),  
  fCutNClustersITS(kFALSE),
  fNClustersITSMax(INT_MAX),
  fNClustersITSMin(INT_MIN),  
  fUseAODFilterBit(kTRUE),
  fAODFilterBit(1),
  fCutDCAToVertexXY(kFALSE),
  fCutDCAToVertexZ(kFALSE),
  fCutMinimalTPCdedx(kFALSE),
  fMinimalTPCdedx(0.),
  fLinearizeVZEROresponse(kFALSE),
  fCutPmdDet(kFALSE),
  fPmdDet(0),
  fCutPmdAdc(kFALSE),
  fPmdAdc(0.),
  fCutPmdNcell(kFALSE),
  fPmdNcell(0.),  
  fMinKinkAngle(TMath::DegToRad()*2.),
  fMinKinkRadius(130.),
  fMaxKinkRadius(200.),
  fMinKinkQt(.05),
  fMaxKinkQt(.5),
  fMinKinkInvMassKmu(0.),
  fMaxKinkInvMassKmu(0.6),
  fForceTPCstandalone(kFALSE),
  fRequireKinkDaughters(kFALSE),
  fParamType(kGlobal),
  fParamMix(kPure),
  fKink(NULL),
  fV0(NULL),
  fTrack(NULL),
  fTrackMass(0.),
  fTrackPt(0.),
  fTrackPhi(0.),
  fTrackEta(0.),
  fTrackWeight(1.),
  fTrackLabel(INT_MIN),
  fMCevent(NULL),
  fMCparticle(NULL),
  fEvent(NULL),
  fTPCtrack(),
  fESDpid(),
  fBayesianResponse(NULL),
  fPIDsource(kTOFpid),
  fTPCpidCuts(NULL),
  fTOFpidCuts(NULL),
  fParticleID(AliPID::kUnknown),
  fParticleProbability(.9),
  fAllowTOFmismatchFlag(kFALSE),
  fRequireStrictTOFTPCagreement(kFALSE),
  fCutRejectElectronsWithTPCpid(kFALSE),
  fProbBayes(0.0),
  fCurrCentr(0.0),
  fVZEROgainEqualization(NULL),
  fApplyRecentering(kFALSE),
  fVZEROgainEqualizationPerRing(kFALSE),
  fChi2A(0x0),
  fChi2C(0x0),
  fChi3A(0x0),
  fChi3C(0x0),
  fPIDResponse(NULL),
  fNsigmaCut2(9)
{
  //io constructor 
  SetPriors(); //init arrays
  
  // New PID procedure (Bayesian Combined PID)
  // allocating here is necessary because we don't 
  // stream this member
  // TODO: fix streaming problems AliFlowBayesianPID
  fBayesianResponse = new AliFlowBayesianPID();
  fBayesianResponse->SetNewTrackParam();
  for(Int_t i(0); i < 4; i++) {
      fVZEROApol[i] = 0;
      fVZEROCpol[i] = 0;
  }
  for(Int_t i(0); i < 8; i++) fUseVZERORing[i] = kTRUE;

}

//-----------------------------------------------------------------------
AliFlowTrackCuts::AliFlowTrackCuts(const char* name):
  AliFlowTrackSimpleCuts(name),
  fAliESDtrackCuts(NULL),
  fMuonTrackCuts(NULL),  // XZhang 20120604
  fQA(NULL),
  fCutMC(kFALSE),
  fCutMChasTrackReferences(kFALSE),
  fCutMCprocessType(kFALSE),
  fMCprocessType(kPNoProcess),
  fCutMCPID(kFALSE),
  fMCPID(0),
  fCutMCfirstMotherPID(kFALSE),
  fMCfirstMotherPID(0),
  fIgnoreSignInMCPID(kFALSE),
  fCutMCisPrimary(kFALSE),
  fRequireTransportBitForPrimaries(kTRUE),
  fMCisPrimary(kFALSE),
  fRequireCharge(kFALSE),
  fFakesAreOK(kTRUE),
  fCutSPDtrackletDeltaPhi(kFALSE),
  fSPDtrackletDeltaPhiMax(FLT_MAX),
  fSPDtrackletDeltaPhiMin(-FLT_MAX),
  fIgnoreTPCzRange(kFALSE),
  fIgnoreTPCzRangeMax(FLT_MAX),
  fIgnoreTPCzRangeMin(-FLT_MAX),
  fCutChi2PerClusterTPC(kFALSE),
  fMaxChi2PerClusterTPC(FLT_MAX),
  fMinChi2PerClusterTPC(-FLT_MAX),
  fCutNClustersTPC(kFALSE),
  fNClustersTPCMax(INT_MAX),
  fNClustersTPCMin(INT_MIN),  
  fCutNClustersITS(kFALSE),
  fNClustersITSMax(INT_MAX),
  fNClustersITSMin(INT_MIN),
  fUseAODFilterBit(kTRUE),
  fAODFilterBit(1),
  fCutDCAToVertexXY(kFALSE),
  fCutDCAToVertexZ(kFALSE),
  fCutMinimalTPCdedx(kFALSE),
  fMinimalTPCdedx(0.),
  fLinearizeVZEROresponse(kFALSE),
  fCutPmdDet(kFALSE),
  fPmdDet(0),
  fCutPmdAdc(kFALSE),
  fPmdAdc(0.),
  fCutPmdNcell(kFALSE),
  fPmdNcell(0.),  
  fMinKinkAngle(TMath::DegToRad()*2.),
  fMinKinkRadius(130.),
  fMaxKinkRadius(200.),
  fMinKinkQt(0.05),
  fMaxKinkQt(0.5),
  fMinKinkInvMassKmu(0.0),
  fMaxKinkInvMassKmu(0.6),
  fForceTPCstandalone(kFALSE),
  fRequireKinkDaughters(kFALSE),
  fParamType(kGlobal),
  fParamMix(kPure),
  fKink(NULL),
  fV0(NULL),
  fTrack(NULL),
  fTrackMass(0.),
  fTrackPt(0.),
  fTrackPhi(0.),
  fTrackEta(0.),
  fTrackWeight(1.),
  fTrackLabel(INT_MIN),
  fMCevent(NULL),
  fMCparticle(NULL),
  fEvent(NULL),
  fTPCtrack(),
  fESDpid(),
  fBayesianResponse(NULL),
  fPIDsource(kTOFpid),
  fTPCpidCuts(NULL),
  fTOFpidCuts(NULL),
  fParticleID(AliPID::kUnknown),
  fParticleProbability(.9),
  fAllowTOFmismatchFlag(kFALSE),
  fRequireStrictTOFTPCagreement(kFALSE),
  fCutRejectElectronsWithTPCpid(kFALSE),
  fProbBayes(0.0),
  fCurrCentr(0.0),
  fVZEROgainEqualization(NULL),
  fApplyRecentering(kFALSE),
  fVZEROgainEqualizationPerRing(kFALSE),
  fChi2A(0x0),
  fChi2C(0x0),
  fChi3A(0x0),
  fChi3C(0x0),
  fPIDResponse(NULL),
  fNsigmaCut2(9)
{
  //constructor 
  SetTitle("AliFlowTrackCuts");
  fESDpid.GetTPCResponse().SetBetheBlochParameters( 0.0283086,
                                                    2.63394e+01,
                                                    5.04114e-11,
                                                    2.12543e+00,
                                                    4.88663e+00 );
  SetPriors(); //init arrays

  // New PID procedure (Bayesian Combined PID)
  fBayesianResponse = new AliFlowBayesianPID();
  fBayesianResponse->SetNewTrackParam();
  for(Int_t i(0); i < 4; i++) {
      fVZEROApol[i] = 0;
      fVZEROCpol[i] = 0;
  }
  for(Int_t i(0); i < 8; i++) fUseVZERORing[i] = kTRUE;
}

//-----------------------------------------------------------------------
AliFlowTrackCuts::AliFlowTrackCuts(const AliFlowTrackCuts& that):
  AliFlowTrackSimpleCuts(that),
  fAliESDtrackCuts(NULL),
  fMuonTrackCuts(NULL),  // XZhang 20120604
  fQA(NULL),
  fCutMC(that.fCutMC),
  fCutMChasTrackReferences(that.fCutMChasTrackReferences),
  fCutMCprocessType(that.fCutMCprocessType),
  fMCprocessType(that.fMCprocessType),
  fCutMCPID(that.fCutMCPID),
  fMCPID(that.fMCPID),
  fCutMCfirstMotherPID(that.fCutMCfirstMotherPID),
  fMCfirstMotherPID(that.fMCfirstMotherPID),
  fIgnoreSignInMCPID(that.fIgnoreSignInMCPID),
  fCutMCisPrimary(that.fCutMCisPrimary),
  fRequireTransportBitForPrimaries(that.fRequireTransportBitForPrimaries),
  fMCisPrimary(that.fMCisPrimary),
  fRequireCharge(that.fRequireCharge),
  fFakesAreOK(that.fFakesAreOK),
  fCutSPDtrackletDeltaPhi(that.fCutSPDtrackletDeltaPhi),
  fSPDtrackletDeltaPhiMax(that.fSPDtrackletDeltaPhiMax),
  fSPDtrackletDeltaPhiMin(that.fSPDtrackletDeltaPhiMin),
  fIgnoreTPCzRange(that.fIgnoreTPCzRange),
  fIgnoreTPCzRangeMax(that.fIgnoreTPCzRangeMax),
  fIgnoreTPCzRangeMin(that.fIgnoreTPCzRangeMin),
  fCutChi2PerClusterTPC(that.fCutChi2PerClusterTPC),
  fMaxChi2PerClusterTPC(that.fMaxChi2PerClusterTPC),
  fMinChi2PerClusterTPC(that.fMinChi2PerClusterTPC),
  fCutNClustersTPC(that.fCutNClustersTPC),
  fNClustersTPCMax(that.fNClustersTPCMax),
  fNClustersTPCMin(that.fNClustersTPCMin),
  fCutNClustersITS(that.fCutNClustersITS),
  fNClustersITSMax(that.fNClustersITSMax),
  fNClustersITSMin(that.fNClustersITSMin),
  fUseAODFilterBit(that.fUseAODFilterBit),
  fAODFilterBit(that.fAODFilterBit),
  fCutDCAToVertexXY(that.fCutDCAToVertexXY),
  fCutDCAToVertexZ(that.fCutDCAToVertexZ),
  fCutMinimalTPCdedx(that.fCutMinimalTPCdedx),
  fMinimalTPCdedx(that.fMinimalTPCdedx),
  fLinearizeVZEROresponse(that.fLinearizeVZEROresponse),
  fCutPmdDet(that.fCutPmdDet),
  fPmdDet(that.fPmdDet),
  fCutPmdAdc(that.fCutPmdAdc),
  fPmdAdc(that.fPmdAdc),
  fCutPmdNcell(that.fCutPmdNcell),
  fPmdNcell(that.fPmdNcell),  
  fMinKinkAngle(that.fMinKinkAngle),
  fMinKinkRadius(that.fMinKinkRadius),
  fMaxKinkRadius(that.fMaxKinkRadius),
  fMinKinkQt(that.fMinKinkQt),
  fMaxKinkQt(that.fMaxKinkQt),
  fMinKinkInvMassKmu(that.fMinKinkInvMassKmu),
  fMaxKinkInvMassKmu(that.fMaxKinkInvMassKmu),
  fForceTPCstandalone(that.fForceTPCstandalone),
  fRequireKinkDaughters(that.fRequireKinkDaughters),
  fParamType(that.fParamType),
  fParamMix(that.fParamMix),
  fKink(NULL),
  fV0(NULL),
  fTrack(NULL),
  fTrackMass(0.),
  fTrackPt(0.),
  fTrackPhi(0.),
  fTrackEta(0.),
  fTrackWeight(1.),
  fTrackLabel(INT_MIN),
  fMCevent(NULL),
  fMCparticle(NULL),
  fEvent(NULL),
  fTPCtrack(),
  fESDpid(that.fESDpid),
  fBayesianResponse(NULL),
  fPIDsource(that.fPIDsource),
  fTPCpidCuts(NULL),
  fTOFpidCuts(NULL),
  fParticleID(that.fParticleID),
  fParticleProbability(that.fParticleProbability),
  fAllowTOFmismatchFlag(that.fAllowTOFmismatchFlag),
  fRequireStrictTOFTPCagreement(that.fRequireStrictTOFTPCagreement),
  fCutRejectElectronsWithTPCpid(that.fCutRejectElectronsWithTPCpid),
  fProbBayes(0.0),
  fCurrCentr(0.0),
  fVZEROgainEqualization(NULL),
  fApplyRecentering(that.fApplyRecentering),
  fVZEROgainEqualizationPerRing(that.fVZEROgainEqualizationPerRing),
  fChi2A(0x0),
  fChi2C(0x0),
  fChi3A(0x0),
  fChi3C(0x0),
  fPIDResponse(that.fPIDResponse),
  fNsigmaCut2(that.fNsigmaCut2)
{
  //copy constructor
  if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts));
  if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts));
  if (that.fAliESDtrackCuts) fAliESDtrackCuts = new AliESDtrackCuts(*(that.fAliESDtrackCuts));
  if (that.fMuonTrackCuts)   fMuonTrackCuts   = new AliMuonTrackCuts(*(that.fMuonTrackCuts));  // XZhang 20120604
  SetPriors(); //init arrays
  if (that.fQA) DefineHistograms();
  // would be neater via copy ctor of TArrayD
  fChi2A = new TArrayD(that.fChi2A->GetSize(), that.fChi2A->GetArray());
  fChi2C = new TArrayD(that.fChi2C->GetSize(), that.fChi2C->GetArray());
  fChi3A = new TArrayD(that.fChi3A->GetSize(), that.fChi3A->GetArray());
  fChi3C = new TArrayD(that.fChi3C->GetSize(), that.fChi3C->GetArray());
  // New PID procedure (Bayesian Combined PID)
  fBayesianResponse = new AliFlowBayesianPID();
  fBayesianResponse->SetNewTrackParam();

  // VZERO gain calibration
  // no reason to init fVZEROgainEqualizationPerRing, will be initialized on node if necessary
  // pointer is set to NULL in initialization list of this constructor
//  if (that.fVZEROgainEqualization) fVZEROgainEqualization = new TH1(*(that.fVZEROgainEqualization));
  for(Int_t i(0); i < 4; i++) { // no use to copy these guys since they're only initialized on worked node
      fVZEROApol[i] = 0.;
      fVZEROCpol[i] = 0.;
  }
  for(Int_t i(0); i < 8; i++) fUseVZERORing[i] = that.fUseVZERORing[i];

}

//-----------------------------------------------------------------------
AliFlowTrackCuts& AliFlowTrackCuts::operator=(const AliFlowTrackCuts& that)
{
  //assignment
  if (this==&that) return *this;

  AliFlowTrackSimpleCuts::operator=(that);
  //the following may seem excessive but if AliESDtrackCuts properly does copy and clone
  //this approach is better memory-fragmentation-wise in some cases
  if (that.fAliESDtrackCuts && fAliESDtrackCuts) *fAliESDtrackCuts=*(that.fAliESDtrackCuts);
  if (that.fAliESDtrackCuts && !fAliESDtrackCuts) fAliESDtrackCuts=new AliESDtrackCuts(*(that.fAliESDtrackCuts));
  if (!that.fAliESDtrackCuts) delete fAliESDtrackCuts; fAliESDtrackCuts=NULL;

  if ( that.fMuonTrackCuts &&  fMuonTrackCuts) *fMuonTrackCuts = *(that.fMuonTrackCuts);                   // XZhang 20120604
  if ( that.fMuonTrackCuts && !fMuonTrackCuts)  fMuonTrackCuts = new AliMuonTrackCuts(*(that.fMuonTrackCuts));  // XZhang 20120604
  if (!that.fMuonTrackCuts) delete fMuonTrackCuts; fMuonTrackCuts = NULL;                                  // XZhang 20120604
  if (!that.fVZEROgainEqualization) delete fVZEROgainEqualization; fVZEROgainEqualization = NULL;
  //these guys we don't need to copy, just reinit
  if (that.fQA) {fQA->Delete(); delete fQA; fQA=NULL; DefineHistograms();} 
  fCutMC=that.fCutMC;
  fCutMChasTrackReferences=that.fCutMChasTrackReferences;
  fCutMCprocessType=that.fCutMCprocessType;
  fMCprocessType=that.fMCprocessType;
  fCutMCPID=that.fCutMCPID;
  fMCPID=that.fMCPID;
  fCutMCfirstMotherPID=that.fCutMCfirstMotherPID;
  fMCfirstMotherPID=that.fMCfirstMotherPID;
  fIgnoreSignInMCPID=that.fIgnoreSignInMCPID,
  fCutMCisPrimary=that.fCutMCisPrimary;
  fRequireTransportBitForPrimaries=that.fRequireTransportBitForPrimaries;
  fMCisPrimary=that.fMCisPrimary;
  fRequireCharge=that.fRequireCharge;
  fFakesAreOK=that.fFakesAreOK;
  fCutSPDtrackletDeltaPhi=that.fCutSPDtrackletDeltaPhi;
  fSPDtrackletDeltaPhiMax=that.fSPDtrackletDeltaPhiMax;
  fSPDtrackletDeltaPhiMin=that.fSPDtrackletDeltaPhiMin;
  fIgnoreTPCzRange=that.fIgnoreTPCzRange;
  fIgnoreTPCzRangeMax=that.fIgnoreTPCzRangeMax;
  fIgnoreTPCzRangeMin=that.fIgnoreTPCzRangeMin;
  fCutChi2PerClusterTPC=that.fCutChi2PerClusterTPC;
  fMaxChi2PerClusterTPC=that.fMaxChi2PerClusterTPC;
  fMinChi2PerClusterTPC=that.fMinChi2PerClusterTPC;
  fCutNClustersTPC=that.fCutNClustersTPC;
  fNClustersTPCMax=that.fNClustersTPCMax;
  fNClustersTPCMin=that.fNClustersTPCMin;  
  fCutNClustersITS=that.fCutNClustersITS;
  fNClustersITSMax=that.fNClustersITSMax;
  fNClustersITSMin=that.fNClustersITSMin;  
  fUseAODFilterBit=that.fUseAODFilterBit;
  fAODFilterBit=that.fAODFilterBit;
  fCutDCAToVertexXY=that.fCutDCAToVertexXY;
  fCutDCAToVertexZ=that.fCutDCAToVertexZ;
  fCutMinimalTPCdedx=that.fCutMinimalTPCdedx;
  fMinimalTPCdedx=that.fMinimalTPCdedx;
  fLinearizeVZEROresponse=that.fLinearizeVZEROresponse;
  fCutPmdDet=that.fCutPmdDet;
  fPmdDet=that.fPmdDet;
  fCutPmdAdc=that.fCutPmdAdc;
  fPmdAdc=that.fPmdAdc;
  fCutPmdNcell=that.fCutPmdNcell;
  fPmdNcell=that.fPmdNcell;
  fMinKinkAngle=that.fMinKinkAngle;
  fMinKinkRadius=that.fMinKinkRadius;
  fMaxKinkRadius=that.fMaxKinkRadius;
  fMinKinkQt=that.fMinKinkQt;
  fMaxKinkQt=that.fMaxKinkQt;
  fMinKinkInvMassKmu=that.fMinKinkInvMassKmu;
  fMaxKinkInvMassKmu=that.fMaxKinkInvMassKmu;
  fForceTPCstandalone=that.fForceTPCstandalone;
  fRequireKinkDaughters=that.fRequireKinkDaughters;
  
  fParamType=that.fParamType;
  fParamMix=that.fParamMix;

  fKink=NULL;
  fV0=NULL;
  fTrack=NULL;
  fTrackMass=0.;
  fTrackPt=0.;
  fTrackEta=0.;
  fTrackPhi=0.;
  fTrackWeight=1.;
  fTrackLabel=INT_MIN;
  fMCevent=NULL;
  fMCparticle=NULL;
  fEvent=NULL;

  fESDpid = that.fESDpid;
  fPIDsource = that.fPIDsource;

  delete fTPCpidCuts;
  delete fTOFpidCuts;
  if (that.fTPCpidCuts) fTPCpidCuts = new TMatrixF(*(that.fTPCpidCuts));
  if (that.fTOFpidCuts) fTOFpidCuts = new TMatrixF(*(that.fTOFpidCuts));

  fParticleID=that.fParticleID;
  fParticleProbability=that.fParticleProbability;
  fAllowTOFmismatchFlag=that.fAllowTOFmismatchFlag;
  fRequireStrictTOFTPCagreement=that.fRequireStrictTOFTPCagreement;
  fCutRejectElectronsWithTPCpid=that.fCutRejectElectronsWithTPCpid;
  fProbBayes = that.fProbBayes;
  fCurrCentr = that.fCurrCentr;
  
  fApplyRecentering = that.fApplyRecentering;
  fVZEROgainEqualizationPerRing = that.fVZEROgainEqualizationPerRing;
#if ROOT_VERSION_CODE < ROOT_VERSION(5,99,0)           
  if (that.fVZEROgainEqualization) fVZEROgainEqualization = new TH1(*(that.fVZEROgainEqualization));
#else
  //PH Lets try Clone, however the result might be wrong
  if (that.fVZEROgainEqualization) fVZEROgainEqualization = (TH1*)that.fVZEROgainEqualization->Clone();
#endif
  for(Int_t i(0); i < 4; i++) { // no use to copy these guys since they're only initialized on worked node
      fVZEROApol[i] = that.fVZEROApol[i];
      fVZEROCpol[i] = that.fVZEROCpol[i];
  }
  for(Int_t i(0); i < 8; i++) fUseVZERORing[i] = that.fUseVZERORing[i];
  // would be neater via copy ctor of TArrayD
  fChi2A = new TArrayD(that.fChi2A->GetSize(), that.fChi2A->GetArray());
  fChi2C = new TArrayD(that.fChi2C->GetSize(), that.fChi2C->GetArray());
  fChi3A = new TArrayD(that.fChi3A->GetSize(), that.fChi3A->GetArray());
  fChi3C = new TArrayD(that.fChi3C->GetSize(), that.fChi3C->GetArray());

  fPIDResponse = that.fPIDResponse;
  fNsigmaCut2 = that.fNsigmaCut2;

  return *this;
}

//-----------------------------------------------------------------------
AliFlowTrackCuts::~AliFlowTrackCuts()
{
  //dtor
  delete fAliESDtrackCuts;
  delete fTPCpidCuts;
  delete fTOFpidCuts;
  if (fMuonTrackCuts) delete fMuonTrackCuts;  // XZhang 20120604
  if (fQA) { fQA->SetOwner(); fQA->Delete(); delete fQA; }
  if (fVZEROgainEqualization) {
      delete fVZEROgainEqualization;
      fVZEROgainEqualization = 0x0;
  }
  if(fChi2A) {
      delete fChi2A;
      fChi2A = 0x0;
  }
  if(fChi3A) {
      delete fChi3A;
      fChi3A = 0x0;
  }
  if(fChi2C) {
      delete fChi2C;
      fChi2C = 0x0;
  }
  if(fChi3C) {
      delete fChi3C;
      fChi3C = 0x0;
  }
}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::SetEvent(AliVEvent* event, AliMCEvent* mcEvent)
{
  //set the event
  Clear();
  fEvent=event;
  fMCevent=mcEvent;

  // Get PID response
  AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
  if(man){
    AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
    if(inputHandler) fPIDResponse=inputHandler->GetPIDResponse();
  }

  //do the magic for ESD
  AliESDEvent* myESD = dynamic_cast<AliESDEvent*>(event);
  AliAODEvent* myAOD = dynamic_cast<AliAODEvent*>(event);
  if (fCutPID && myESD)
  {
    //TODO: maybe call it only for the TOF options?
    // Added by F. Noferini for TOF PID
    // old procedure now implemented inside fBayesianResponse
    //    fESDpid.MakePID(myESD,kFALSE);
    // new procedure
    fBayesianResponse->SetDetResponse(myESD, fCurrCentr,AliESDpid::kTOF_T0,kTRUE); // centrality = PbPb centrality class (0-100%) or -1 for pp collisions
    fESDpid.SetTOFResponse(myESD,AliESDpid::kTOF_T0);
    // End F. Noferini added part
  }
  if (fCutPID && myAOD){
    fBayesianResponse->SetDetResponse(myAOD, fCurrCentr,AliESDpid::kTOF_T0); // centrality = PbPb centrality class (0-100%) or -1 for pp collisions
    if(myAOD->GetTOFHeader()){
      fESDpid.SetTOFResponse(myAOD,AliESDpid::kTOF_T0);
    }   
    else{ // corrected on the fly track by track if tof header is not present (old AODs)
    }
    // End F. Noferini added part
  }
  
  if(fPIDsource==kTOFbayesian) fBayesianResponse->SetDetAND(1);
  else if(fPIDsource==kTPCbayesian) fBayesianResponse->ResetDetOR(1);
}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::SetCutMC( Bool_t b )
{
  //will we be cutting on MC information?
  fCutMC=b;

  //if we cut on MC info then also the Bethe Bloch should be the one tuned for MC
  if (fCutMC)
  {
    fESDpid.GetTPCResponse().SetBetheBlochParameters( 2.15898e+00/50.,
                                                       1.75295e+01,
                                                       3.40030e-09,
                                                       1.96178e+00,
                                                       3.91720e+00);
  }
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::IsSelected(TObject* obj, Int_t id)
{
  //check cuts
  AliVParticle* vparticle = dynamic_cast<AliVParticle*>(obj);
//if (vparticle) return PassesCuts(vparticle);                // XZhang 20120604
  if (vparticle) {                                            // XZhang 20120604
    if (fParamType==kMUON) return PassesMuonCuts(vparticle);  // XZhang 20120604
    return PassesCuts(vparticle);                             // XZhang 20120604
  }                                                           // XZhang 20120604

  AliFlowTrackSimple* flowtrack = dynamic_cast<AliFlowTrackSimple*>(obj);
  if (flowtrack) return PassesCuts(flowtrack);
  AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj);
  if (tracklets) return PassesCuts(tracklets,id);
  AliAODTracklets* trkletAOD = dynamic_cast<AliAODTracklets*>(obj);  // XZhang 20120615
  if (trkletAOD) return PassesCuts(trkletAOD,id);                    // XZhang 20120615
  AliESDPmdTrack* pmdtrack = dynamic_cast<AliESDPmdTrack*>(obj);
  if (pmdtrack) return PassesPMDcuts(pmdtrack);
  AliVVZERO* vvzero = dynamic_cast<AliVVZERO*>(obj);    // downcast to base class
  if (vvzero) return PassesVZEROcuts(id);
  AliESDkink* kink = dynamic_cast<AliESDkink*>(obj);
  if (kink) return PassesCuts(kink);
  //AliESDv0* v0 = dynamic_cast<AliESDv0*>(obj);
  //if (v0) return PassesCuts(v0);
 
  return kFALSE;  //default when passed wrong type of object
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::IsSelectedMCtruth(TObject* obj, Int_t id)
{
  //check cuts
  AliVParticle* vparticle = dynamic_cast<AliVParticle*>(obj);
  if (vparticle) 
  {
    return PassesMCcuts(fMCevent,(fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel());
  }
  AliMultiplicity* tracklets = dynamic_cast<AliMultiplicity*>(obj);
  if (tracklets)
  {
    Int_t label0 = tracklets->GetLabel(id,0);
    Int_t label1 = tracklets->GetLabel(id,1);
    Int_t label = (fFakesAreOK)?TMath::Abs(label0):label0;
    if (label0!=label1) label = -666;
    return PassesMCcuts(fMCevent,label);
  }
  return kFALSE;  //default when passed wrong type of object
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesCuts(const AliFlowTrackSimple* track)
{
  //check cuts on a flowtracksimple

  //clean up from last iteration
  ClearTrack();
  return AliFlowTrackSimpleCuts::PassesCuts(track);
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesCuts(const AliMultiplicity* tracklet, Int_t id)
{
  //check cuts on a tracklets

  if (id<0) return kFALSE;

  //clean up from last iteration, and init label
  ClearTrack();

  fTrackPhi = tracklet->GetPhi(id);
  fTrackEta = tracklet->GetEta(id);
  fTrackWeight = 1.0;
  if (fCutEta) {if (  fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) return kFALSE;}
  if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) return kFALSE;}

  //check MC info if available
  //if the 2 clusters have different label track cannot be good
  //and should therefore not pass the mc cuts
  Int_t label0 = tracklet->GetLabel(id,0);
  Int_t label1 = tracklet->GetLabel(id,1);
  //if possible get label and mcparticle
  fTrackLabel = (label0==label1)?tracklet->GetLabel(id,1):-1;
  if (!fFakesAreOK && fTrackLabel<0) return kFALSE;
  if (fTrackLabel>=0 && fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
  //check MC cuts
  if (fCutMC && !PassesMCcuts()) return kFALSE;
  return kTRUE;
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesCuts(const AliAODTracklets* tracklet, Int_t id)
{
  // XZhang 20120615
  //check cuts on a tracklets

  if (id<0) return kFALSE;

  //clean up from last iteration, and init label
  ClearTrack();

  fTrackPhi = tracklet->GetPhi(id);
//fTrackEta = tracklet->GetEta(id);
  fTrackEta = -1.*TMath::Log(TMath::Tan(tracklet->GetTheta(id)/2.));
  fTrackWeight = 1.0;
  if (fCutEta) {if (  fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) return kFALSE;}
  if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) return kFALSE;}

  //check MC info if available
  //if the 2 clusters have different label track cannot be good
  //and should therefore not pass the mc cuts
  Int_t label0 = tracklet->GetLabel(id,0);
  Int_t label1 = tracklet->GetLabel(id,1);
  //if possible get label and mcparticle
  fTrackLabel = (label0==label1)?tracklet->GetLabel(id,1):-1;
  if (!fFakesAreOK && fTrackLabel<0) return kFALSE;
  if (fTrackLabel>=0 && fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
  //check MC cuts
  if (fCutMC && !PassesMCcuts()) return kFALSE;
  return kTRUE;
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesMCcuts(AliMCEvent* mcEvent, Int_t label)
{
  //check the MC info
  if (!mcEvent) return kFALSE;
  if (label<0) return kFALSE;//otherwise AliCMevent prints a warning before returning NULL
  AliMCParticle* mcparticle = static_cast<AliMCParticle*>(mcEvent->GetTrack(label));
  if (!mcparticle) {AliError("no MC track"); return kFALSE;}

  if (fCutMCisPrimary)
  {
    if (IsPhysicalPrimary(mcEvent,label,fRequireTransportBitForPrimaries) != fMCisPrimary) return kFALSE;
  }
  if (fCutMCPID)
  {
    Int_t pdgCode = mcparticle->PdgCode();
    if (fIgnoreSignInMCPID) 
    {
      if (TMath::Abs(fMCPID) != TMath::Abs(pdgCode)) return kFALSE;
    }
    else 
    {
      if (fMCPID != pdgCode) return kFALSE;
    }
  }
  if (fCutMCfirstMotherPID)
  {

    TParticle* tparticle=mcparticle->Particle();
    Int_t firstMotherLabel = 0;
    if (tparticle) { firstMotherLabel = tparticle->GetFirstMother(); }
    AliVParticle* firstMotherParticle = mcEvent->GetTrack(firstMotherLabel);
    Int_t pdgcodeFirstMother = 0;
    if (firstMotherParticle) { pdgcodeFirstMother = firstMotherParticle->PdgCode(); }
    if (pdgcodeFirstMother != fMCfirstMotherPID) return kFALSE;
  }
  if ( fCutMCprocessType )
  {
    TParticle* particle = mcparticle->Particle();
    Int_t processID = particle->GetUniqueID();
    if (processID != fMCprocessType ) return kFALSE;
  }
  if (fCutMChasTrackReferences)
  {
    if (mcparticle->GetNumberOfTrackReferences()<1) return kFALSE;
  }
  return kTRUE;
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesMCcuts()
{
  //check MC info
  if (!fMCevent) return kFALSE;
  if (fTrackLabel<0) return kFALSE;//otherwise AliCMevent prints a warning before returning NULL
  fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
  return PassesMCcuts(fMCevent,fTrackLabel);
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesCuts(const AliESDv0* v0)
{
  //check if the v0 passes cuts

  //clean up from last iteration
  ClearTrack();
  
  fV0 = const_cast<AliESDv0*>(v0);

  Bool_t pass = kTRUE;

  //first, extract/prepare the v0
  if (!v0->GetOnFlyStatus()) return kFALSE; //skip offline V0 finder
  const AliExternalTrackParam *negHelix=v0->GetParamN();
  const AliExternalTrackParam *posHelix=v0->GetParamP();
  AliVParticle *v0tracks[2];
  v0tracks[0] = fEvent->GetTrack(v0->GetNindex());
  v0tracks[1] = fEvent->GetTrack(v0->GetPindex());
  if( v0tracks[1]->Charge() < 0)
  {
    v0tracks[1] = fEvent->GetTrack(v0->GetNindex());
    v0tracks[0] = fEvent->GetTrack(v0->GetPindex());
    negHelix=v0->GetParamP();
    posHelix=v0->GetParamN();
  }

  int KalmanPidPairs[4][2] =
  {
    {-11,11}, // e-,e+ (gamma)
    {-211,2212}, // pi- p (lambda)
    {-2212,211}, // anti-p pi+ (anti-lambda)
    {-211,211} // pi-  pi+ (Kshort)
    //   {-321,321} // K- K+ (phi)
  };
    
  Int_t id = 3;
  //refit using a mass hypothesis
  AliKFParticle v0trackKFneg(*(negHelix),KalmanPidPairs[id][0]);
  AliKFParticle v0trackKFpos(*(posHelix),KalmanPidPairs[id][1]);
  AliKFParticle v0particleRefit;
  v0particleRefit += v0trackKFneg;
  v0particleRefit += v0trackKFpos;
  Double_t invMassErr= -999;
  v0particleRefit.GetMass(fTrackMass,invMassErr);
  //Double_t openAngle = v0trackKFneg.GetAngle(v0trackKFpos);
  fTrackEta = v0particleRefit.GetEta();
  fTrackPt = v0particleRefit.GetPt();
  fTrackPhi = TMath::Pi()+v0particleRefit.GetPhi();
  ////find out which mass bin and put the number in fPOItype
  //Int_t massBins = AliFlowCommonConstants::GetMaster()->GetNbinsMass();
  //Double_t massMin = AliFlowCommonConstants::GetMaster()->GetMassMin();
  //Double_t massMax = AliFlowCommonConstants::GetMaster()->GetMassMax();
  //fPOItype = 1 + int(massBins*(fTrackMass-massMin)/(massMax-massMin));
  
  /////////////////////////////////////////////////////////////////////////////
  //apply cuts
  if ( v0tracks[0]->Charge() == v0tracks[1]->Charge() ) pass=kFALSE;
  if ( v0tracks[0]->Pt()<0.15 || v0tracks[1]->Pt()<0.15 ) pass=kFALSE;

  return pass;
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesCuts(const AliESDkink* kink)
{
  //check if the kink passes cuts
  
  //clean up from last iteration
  ClearTrack();
  fKink=const_cast<AliESDkink*>(kink);

  Bool_t pass = kTRUE;

  Float_t kinkAngle = kink->GetAngle(2);
  if (kinkAngle<fMinKinkAngle) pass = kFALSE;
  Double_t kinkRadius = kink->GetR();
  if (kinkRadius<fMinKinkRadius || kinkRadius>fMaxKinkRadius) pass = kFALSE;

  //Qt
  const TVector3 motherMfromKink(kink->GetMotherP());
  const TVector3 daughterMfromKink(kink->GetDaughterP());
  Float_t qt=kink->GetQt();
  if ( qt < fMinKinkQt || qt > fMaxKinkQt) pass = kFALSE;

  //invariant mass
  Float_t energyDaughterMu = TMath::Sqrt( daughterMfromKink.Mag()*daughterMfromKink.Mag()+
                                          0.105658*0.105658 );
  Float_t p1XM = motherMfromKink.Px();
  Float_t p1YM = motherMfromKink.Py();
  Float_t p1ZM = motherMfromKink.Pz();
  Float_t p2XM = daughterMfromKink.Px();
  Float_t p2YM = daughterMfromKink.Py();
  Float_t p2ZM = daughterMfromKink.Pz();
  Float_t p3Daughter = TMath::Sqrt( ((p1XM-p2XM)*(p1XM-p2XM))+((p1YM-p2YM)*(p1YM-p2YM))+
                                    ((p1ZM-p2ZM)*(p1ZM-p2ZM)) );
  Double_t invariantMassKmu = TMath::Sqrt( (energyDaughterMu+p3Daughter)*(energyDaughterMu+p3Daughter)-
                                           motherMfromKink.Mag()*motherMfromKink.Mag() );
  if (invariantMassKmu > fMaxKinkInvMassKmu) pass=kFALSE;
  if (invariantMassKmu < fMinKinkInvMassKmu) pass=kFALSE;
  fTrackMass=invariantMassKmu;

  if (fQA)
  {
    QAbefore(13)->Fill(qt);
    if (pass) QAafter(13)->Fill(qt);
    QAbefore(14)->Fill(invariantMassKmu);
    if (pass) QAafter(14)->Fill(invariantMassKmu);
    const Double_t* kinkPosition = kink->GetPosition();
    QAbefore(15)->Fill(kinkPosition[0],kinkPosition[1]);
    if (pass) QAafter(15)->Fill(kinkPosition[0],kinkPosition[1]);
    QAbefore(16)->Fill(motherMfromKink.Mag(),kinkAngle*TMath::RadToDeg());
    if (pass) QAafter(16)->Fill(motherMfromKink.Mag(),kinkAngle*TMath::RadToDeg());
  }

  //mother track cuts
  Int_t indexKinkMother = kink->GetIndex(0);
  AliESDtrack* motherTrack = dynamic_cast<AliESDtrack*>(fEvent->GetTrack(indexKinkMother));
  if (!motherTrack) return kFALSE;
  if (!PassesCuts(motherTrack)) pass = kFALSE;
  
  return pass;
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesCuts(AliVParticle* vparticle)
{
  //check cuts for an ESD vparticle

  ////////////////////////////////////////////////////////////////
  //  start by preparing the track parameters to cut on //////////
  ////////////////////////////////////////////////////////////////
  //clean up from last iteration
  ClearTrack();
  Bool_t pass=kTRUE;

  //get the label and the mc particle
  fTrackLabel = (fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel();
  if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
  else fMCparticle=NULL;

  Bool_t isMCparticle = kFALSE; //some things are different for MC particles, check!
  AliESDtrack* esdTrack = dynamic_cast<AliESDtrack*>(vparticle);
  AliAODTrack* aodTrack = NULL;
  if (esdTrack)
  {
    //for an ESD track we do some magic sometimes like constructing TPC only parameters
    //or doing some hybrid, handle that here
    HandleESDtrack(esdTrack);
  }
  else
  {
    HandleVParticle(vparticle);
    //now check if produced particle is MC
    isMCparticle = (dynamic_cast<AliMCParticle*>(fTrack))!=NULL;
    aodTrack = dynamic_cast<AliAODTrack*>(vparticle); //keep the additional dynamic cast out of the way for ESDs
  }
  ////////////////////////////////////////////////////////////////
  ////////////////////////////////////////////////////////////////

  if (!fTrack) return kFALSE;
  //because it may be different from global, not needed for aodTrack because we dont do anything funky there
  if (esdTrack) esdTrack = static_cast<AliESDtrack*>(fTrack);
  
  //check the common cuts for the current particle fTrack (MC,AOD,ESD)
  Double_t pt = fTrack->Pt();
  Double_t p = fTrack->P();
  if (!fFakesAreOK) {if (fTrackLabel<0) pass=kFALSE;}
  if (fCutPt) {if (pt < fPtMin || pt >= fPtMax ) pass=kFALSE;}
  if (fCutEta) {if (fTrack->Eta() < fEtaMin || fTrack->Eta() >= fEtaMax ) pass=kFALSE;}
  if (fCutPhi) {if (fTrack->Phi() < fPhiMin || fTrack->Phi() >= fPhiMax ) pass=kFALSE;}
  if (fRequireCharge) {if (fTrack->Charge() == 0) pass=kFALSE;}
  if (fCutCharge && !isMCparticle) {if (fTrack->Charge() != fCharge) pass=kFALSE;}
  if (fCutCharge && isMCparticle)
  { 
    //in case of an MC particle the charge is stored in units of 1/3|e| 
    Int_t charge = TMath::Nint(fTrack->Charge()/3.0); //mc particles have charge in units of 1/3e
    if (charge!=fCharge) pass=kFALSE;
  }
  //if(fCutPID) {if (fTrack->PID() != fPID) pass=kFALSE;}

  //when additionally MC info is required
  if (fCutMC && !PassesMCcuts()) pass=kFALSE;

  //the case of ESD or AOD
  if (esdTrack) { if (!PassesESDcuts(esdTrack)) { pass=kFALSE; } }
  if (aodTrack) { if (!PassesAODcuts(aodTrack,pass)) { pass=kFALSE; } }

  if (fQA)
  {
    if (fMCparticle)
    {
      TParticle* tparticle=fMCparticle->Particle();
      Int_t processID = tparticle->GetUniqueID();
      Int_t firstMotherLabel = tparticle->GetFirstMother();
      Bool_t primary = IsPhysicalPrimary();
      //TLorentzVector v;
      //mcparticle->Particle()->ProductionVertex(v);
      //Double_t prodvtxX = v.X();
      //Double_t prodvtxY = v.Y();

      Int_t pdgcode = fMCparticle->PdgCode();
      AliVParticle* firstMotherParticle = fMCevent->GetTrack(firstMotherLabel);
      Int_t pdgcodeFirstMother = 0;
      if (firstMotherParticle) {pdgcodeFirstMother = firstMotherParticle->PdgCode();}
      
      Float_t pdg = 0;
      switch (TMath::Abs(pdgcode))
      {
        case 11:
          pdg = AliPID::kElectron + 0.5; break;
        case 13:
          pdg = AliPID::kMuon + 0.5; break;
        case 211:
          pdg = AliPID::kPion + 0.5; break;
        case 321:
          pdg = AliPID::kKaon + 0.5; break;
        case 2212:
          pdg = AliPID::kProton + 0.5; break;
        default:
          pdg = AliPID::kUnknown + 0.5; break;
      }
      pdg = TMath::Sign(pdg,static_cast<Float_t>(pdgcode));

      Float_t geantCode = 0;
      switch (pdgcodeFirstMother)
      {
        case 22: //#gamma
          geantCode=1;
          break;
        case -11: //e^{+}
          geantCode=2;
          break;
        case 11: //e^{-}
          geantCode=3;
          break;
        case 12: case 14: case 16: //#nu
          geantCode=4;
          break;
        case -13:
          geantCode=5; //#mu^{+}
          break;
        case 13:
          geantCode=6; //#mu^{-}
          break;
        case 111: //#pi^{0}
          geantCode=7;
          break;
        case 211: //#pi^{+}
          geantCode=8;
          break;
        case -211: //#pi^{-}
          geantCode=9;
          break;
        case 130: //K^{0}_{L}
          geantCode=10;
          break;
        case 321: //K^{+}
          geantCode=11;
          break;
        case -321: //K^{-}
          geantCode=12;
          break;
        case 2112:
          geantCode = 13; //n
          break;
        case 2212:
          geantCode = 14; //p
          break;
        case -2212:
          geantCode=15; //#bar{p}
          break;
        case 310:
          geantCode=16; //K^{0}_{S}
          break;
        case 221:
          geantCode=17; //#eta
          break;
        case 3122:
          geantCode=18; //#Lambda
          break;
        case 3222:
          geantCode=19; //#Sigma^{+}
          break;
        case 3212:
          geantCode=20; //#Sigma^{0}
          break;
        case 3112:
          geantCode=21; //#Sigma^{-}
          break;
        case 3322:
          geantCode=22; //#Theta^{0}
          break;
        case 3312:
          geantCode=23; //#Theta^{-}
          break;
        case 3332:
          geantCode=24; //#Omega^{-}
          break;
        case -2112:
          geantCode=25; //#bar{n}
          break;
        case -3122:
          geantCode=26; //#bar{#Lambda}
          break;
        case -3112:
          geantCode=27; //#bar{#Sigma}^{-}
          break;
        case -3212:
          geantCode=28; //#bar{#Sigma}^{0}
          break;
        case -3222:
          geantCode=29; //#bar{#Sigma}^{+}
          break;
        case -3322:
          geantCode=30; //#bar{#Theta}^{0}
          break;
        case -3312:
          geantCode=31; //#bar{#Theta}^{+}
          break;
        case -3332:
          geantCode=32; //#bar{#Omega}^{+}
          break;
        case -15:
          geantCode=33; //#tau^{+}
          break;
        case 15:
          geantCode=34; //#tau^{-}
          break;
        case 411:
          geantCode=35; //D^{+}
          break;
        case -411:
          geantCode=36; //D^{-}
          break;
        case 421:
          geantCode=37; //D^{0}
          break;
        case -421:
          geantCode=38; //#bar{D}^{0}
          break;
        case 431:
          geantCode=39; //D_{s}^{+}
          break;
        case -431:
          geantCode=40; //#bar{D_{s}}^{-}
          break;
        case 4122:
          geantCode=41; //#Lambda_{c}^{+}
          break;
        case 24:
          geantCode=42; //W^{+}
          break;
        case -24:
          geantCode=43; //W^{-}
          break;
        case 23:
          geantCode=44; //Z^{0}
          break;
        default:
          geantCode = 100;
          break;
      }
      
      QAbefore(2)->Fill(p,pdg);
      QAbefore(3)->Fill(p,primary?0.5:-0.5);
      QAbefore(4)->Fill(p,static_cast<Float_t>(processID));
      QAbefore(7)->Fill(p,geantCode+0.5);
      if (pass) QAafter(2)->Fill(p,pdg);
      if (pass) QAafter(3)->Fill(p,primary?0.5:-0.5);
      if (pass) QAafter(4)->Fill(p,static_cast<Float_t>(processID));
      if (pass) QAafter(7)->Fill(p,geantCode);
    }
  }

  //true by default, if we didn't set any cuts
  return pass;
}

//_______________________________________________________________________
Bool_t AliFlowTrackCuts::PassesAODcuts(const AliAODTrack* track, Bool_t passedFid)
{
  //check cuts for AOD
  Bool_t pass = passedFid;

  if (fCutNClustersTPC)
  {
    Int_t ntpccls = track->GetTPCNcls();
    if (ntpccls < fNClustersTPCMin || ntpccls > fNClustersTPCMax) pass=kFALSE;
  }

  if (fCutNClustersITS)
  {
    Int_t nitscls = track->GetITSNcls();
    if (nitscls < fNClustersITSMin || nitscls > fNClustersITSMax) pass=kFALSE;
  }
  
   if (fCutChi2PerClusterTPC)
  {
    Double_t chi2tpc = track->Chi2perNDF();
    if (chi2tpc < fMinChi2PerClusterTPC || chi2tpc > fMaxChi2PerClusterTPC) pass=kFALSE;
  }
  
  if (GetRequireTPCRefit() && !(track->GetStatus() & AliESDtrack::kTPCrefit) ) pass=kFALSE;
  if (GetRequireITSRefit() && !(track->GetStatus() & AliESDtrack::kITSrefit) ) pass=kFALSE;
  
  if (fUseAODFilterBit && !track->TestFilterBit(fAODFilterBit)) pass=kFALSE;
  
  if (fCutDCAToVertexXY && track->DCA()>GetMaxDCAToVertexXY()) pass=kFALSE;

  if (fCutDCAToVertexZ && track->ZAtDCA()>GetMaxDCAToVertexZ()) pass=kFALSE;

  Double_t dedx = track->GetTPCsignal();
  if (dedx < fMinimalTPCdedx) pass=kFALSE;
  Double_t time[9];
  track->GetIntegratedTimes(time);
  if (fCutPID && (fParticleID!=AliPID::kUnknown)) //if kUnknown don't cut on PID
    {
      if (!PassesAODpidCut(track)) pass=kFALSE;
    }

  if (fQA) {
    // changed 04062014 used to be filled before possible PID cut
    Double_t momTPC = track->GetTPCmomentum();
    QAbefore( 0)->Fill(momTPC,GetBeta(track, kTRUE));
    if(pass) QAafter( 0)->Fill(momTPC, GetBeta(track, kTRUE));
    QAbefore( 1)->Fill(momTPC,dedx);
    QAbefore( 5)->Fill(track->Pt(),track->DCA());
    QAbefore( 6)->Fill(track->Pt(),track->ZAtDCA());
    if (pass) QAafter( 1)->Fill(momTPC,dedx);
    if (pass) QAafter( 5)->Fill(track->Pt(),track->DCA());
    if (pass) QAafter( 6)->Fill(track->Pt(),track->ZAtDCA());
    QAbefore( 8)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kElectron]));
    if (pass) QAafter(  8)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kElectron]));
    QAbefore( 9)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kMuon]));
    if (pass) QAafter(  9)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kMuon]));
    QAbefore(10)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kPion]));
    if (pass) QAafter( 10)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kPion]));
    QAbefore(11)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kKaon]));
    if (pass) QAafter( 11)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kKaon]));
    QAbefore(12)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kProton]));
    if (pass) QAafter( 12)->Fill(track->P(),(track->GetTOFsignal()-time[AliPID::kProton]));
  }


  return pass;
}

//_______________________________________________________________________
Bool_t AliFlowTrackCuts::PassesESDcuts(AliESDtrack* track)
{
  //check cuts on ESD tracks
  Bool_t pass=kTRUE;
  Float_t dcaxy=0.0;
  Float_t dcaz=0.0;
  track->GetImpactParameters(dcaxy,dcaz);
  const AliExternalTrackParam* pout = track->GetOuterParam();
  const AliExternalTrackParam* pin = track->GetInnerParam();
  if (fIgnoreTPCzRange)
  {
    if (pin&&pout)
    {
      Double_t zin = pin->GetZ();
      Double_t zout = pout->GetZ();
      if (zin*zout<0) pass=kFALSE;   //reject if cross the membrane
      if (zin < fIgnoreTPCzRangeMin || zin > fIgnoreTPCzRangeMax) pass=kFALSE;
      if (zout < fIgnoreTPCzRangeMin || zout > fIgnoreTPCzRangeMax) pass=kFALSE;
    }
  }
 
  Int_t ntpccls = ( fParamType==kTPCstandalone )?
                    track->GetTPCNclsIter1():track->GetTPCNcls();    
  if (fCutChi2PerClusterTPC)
  {
    Float_t tpcchi2 = (fParamType==kTPCstandalone)?
                       track->GetTPCchi2Iter1():track->GetTPCchi2();
    tpcchi2 = (ntpccls>0)?tpcchi2/ntpccls:-FLT_MAX;
    if (tpcchi2<fMinChi2PerClusterTPC || tpcchi2 >=fMaxChi2PerClusterTPC)
      pass=kFALSE;
  }

  if (fCutMinimalTPCdedx) 
  {
    if (track->GetTPCsignal() < fMinimalTPCdedx) pass=kFALSE;
  }

  if (fCutNClustersTPC)
  {
    if (ntpccls < fNClustersTPCMin || ntpccls > fNClustersTPCMax) pass=kFALSE;
  }

  Int_t nitscls = track->GetNcls(0);
  if (fCutNClustersITS)
  {
    if (nitscls < fNClustersITSMin || nitscls > fNClustersITSMax) pass=kFALSE;
  }

  //some stuff is still handled by AliESDtrackCuts class - delegate
  if (fAliESDtrackCuts)
  {
    if (!fAliESDtrackCuts->IsSelected(track)) pass=kFALSE;
  }
 
  //PID part with pid QA
  Double_t beta = GetBeta(track);
  Double_t dedx = Getdedx(track);
  if (fQA)
  {
    if (pass) QAbefore(0)->Fill(track->GetP(),beta);
    if (pass) QAbefore(1)->Fill(pin->GetP(),dedx);
  }
  if (fCutPID && (fParticleID!=AliPID::kUnknown)) //if kUnknown don't cut on PID
  {
    if (!PassesESDpidCut(track)) pass=kFALSE;
  }
  if (fCutRejectElectronsWithTPCpid)
  {
    //reject electrons using standard TPC pid
    //TODO this should be rethought....
    Double_t pidTPC[AliPID::kSPECIES];
    track->GetTPCpid(pidTPC);
    if (pidTPC[AliPID::kElectron]<fParticleProbability) pass=kFALSE;
  }
  if (fQA)
  {
    if (pass) QAafter(0)->Fill(track->GetP(),beta);
    if (pass) QAafter(1)->Fill(pin->GetP(),dedx);
  }
  //end pid part with qa
  
  if (fQA)
  {
    Double_t pt = track->Pt();
    QAbefore(5)->Fill(pt,dcaxy);
    QAbefore(6)->Fill(pt,dcaz);
    if (pass) QAafter(5)->Fill(pt,dcaxy);
    if (pass) QAafter(6)->Fill(pt,dcaz);
    QAbefore(17)->Fill(Float_t(track->GetKinkIndex(0)));
    if (pass) QAafter(17)->Fill(Float_t(track->GetKinkIndex(0)));
  }

  return pass;
}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::HandleVParticle(AliVParticle* track)
{
  //handle the general case
  switch (fParamType)
  {
    default:
      fTrack = track;
      break;
  }
}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::HandleESDtrack(AliESDtrack* track)
{
  //handle esd track
  switch (fParamType)
  {
    case kGlobal:
      fTrack = track;
      break;
    case kTPCstandalone:
      if (!track->FillTPCOnlyTrack(fTPCtrack)) 
      {
        fTrack=NULL;
        fMCparticle=NULL;
        fTrackLabel=-998;
        return;
      }
      fTrack = &fTPCtrack;
      //recalculate the label and mc particle, they may differ as TPClabel != global label
      fTrackLabel = (fFakesAreOK)?TMath::Abs(fTrack->GetLabel()):fTrack->GetLabel();
      if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
      else fMCparticle=NULL;
      break;
    default:
      if (fForceTPCstandalone)
      {
        if (!track->FillTPCOnlyTrack(fTPCtrack))
        {
          fTrack=NULL;
          fMCparticle=NULL;
          fTrackLabel=-998;
          return;
        }
        fTrack = &fTPCtrack;
        //recalculate the label and mc particle, they may differ as TPClabel != global label
        fTrackLabel = (fFakesAreOK)?TMath::Abs(fTrack->GetLabel()):fTrack->GetLabel();
        if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
        else fMCparticle=NULL;
      }
      else 
        fTrack = track;
      break;
  }
}

//-----------------------------------------------------------------------
Int_t AliFlowTrackCuts::Count(AliVEvent* event)
{
  //calculate the number of track in given event.
  //if argument is NULL(default) take the event attached
  //by SetEvent()
  Int_t multiplicity = 0;
  if (!event)
  {
    for (Int_t i=0; i<GetNumberOfInputObjects(); i++)
    {
      if (IsSelected(GetInputObject(i))) multiplicity++;
    }
  }
  else
  {
    for (Int_t i=0; i<event->GetNumberOfTracks(); i++)
    {
      if (IsSelected(event->GetTrack(i))) multiplicity++;
    }
  }
  return multiplicity;
}

//-----------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetAODTrackCutsForFilterBit(UInt_t bit, TString suffix)
{
  // object which in its default form only cuts on filterbit (for AOD analysis)
  // NOTE : the cut object is defined in such a way that ONLY filterbit is tested, 
  // all other paramters are NOT checked 
  // the exception is TPCdecx which is always cut for reasons of backward compatibility
  // but by setting the threshold to larger than -99999999 effectively there is no check
  AliFlowTrackCuts* cuts = new AliFlowTrackCuts(Form("AOD fitlerbit %i, %s", (int)bit, suffix.Data()));
  cuts->SetMinimalTPCdedx(-999999999);
  cuts->SetAODfilterBit(bit);
  cuts->SetParamType(AliFlowTrackCuts::kAODFilterBit);
  return cuts;
}  
//-----------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetStandardVZEROOnlyTrackCuts()
{
  //returns the lhc10h vzero track cuts, this function
  //is left here for backward compatibility
  //if a run is recognized as 11h, the calibration method will
  //switch to 11h calbiration, which means that the cut 
  //object is updated but not replaced.
  //calibratin is only available for PbPb runs
  return GetStandardVZEROOnlyTrackCuts2010();
}
//-----------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetStandardVZEROOnlyTrackCuts2010()
{
  //get standard VZERO cuts
  //DISCLAIMER: LHC10h VZERO calibration consists (by default) of two steps
  //1) re-weigting of signal
  //2) re-centering of q-vectors
  //step 2 is available only for n==2 and n==3, for the higher harmonics the user
  //is repsonsible for making sure the q-sub distributions are (sufficiently) flat
  //or a sensible NUA procedure is applied !
  AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard vzero flow cuts");
  cuts->SetParamType(AliFlowTrackCuts::kVZERO);
  cuts->SetEtaRange( -10, +10 );
  cuts->SetEtaGap(-1., 1.);
  cuts->SetPhiMin( 0 );
  cuts->SetPhiMax( TMath::TwoPi() );
  // options for the reweighting
  cuts->SetVZEROgainEqualizationPerRing(kFALSE);
  cuts->SetApplyRecentering(kTRUE);
  // to exclude a ring , do e.g. 
  // cuts->SetUseVZERORing(7, kFALSE);
  // excluding a ring will break the re-centering as re-centering relies on a 
  // database file which tuned to receiving info from all rings
  return cuts;
}
//-----------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetStandardVZEROOnlyTrackCuts2011()
{
  //get standard VZERO cuts for 2011 data
  //in this case, the vzero segments will be weighted by
  //VZEROEqMultiplicity, 
  //if recentering is enableded, the sub-q vectors
  //will be taken from the event header, so make sure to run 
  //the VZERO event plane selection task before this task !
  //DISCLAIMER: recentering is only available for n==2
  //for the higher harmonics the user
  //is repsonsible for making sure the q-sub distributions are (sufficiently) flat
  //or a sensible NUA procedure is applied !
  //recentering replaces the already evaluated q-vectors, so 
  //when chosen, additional settings (e.g. excluding rings) 
  //have no effect. recentering is true by default
  //
  //NOTE user is responsible for running the vzero event plane
  //selection task in advance, e.g. add to your launcher macro
  //
  //  gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskVZEROEPSelection.C");
  //  AddTaskVZEROEPSelection();
  //
  AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard vzero flow cuts 2011");
  cuts->SetParamType(kVZERO);
  cuts->SetEtaRange( -10, +10 );
  cuts->SetEtaGap(-1., 1.);
  cuts->SetPhiMin( 0 );
  cuts->SetPhiMax( TMath::TwoPi() );
  cuts->SetApplyRecentering(kTRUE);
  cuts->SetVZEROgainEqualizationPerRing(kFALSE);
 return cuts;
}
//-----------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetStandardGlobalTrackCuts2010()
{
  //get standard cuts
  AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard Global tracks");
  cuts->SetParamType(kGlobal);
  cuts->SetPtRange(0.2,5.);
  cuts->SetEtaRange(-0.8,0.8);
  cuts->SetMinNClustersTPC(70);
  cuts->SetMinChi2PerClusterTPC(0.1);
  cuts->SetMaxChi2PerClusterTPC(4.0);
  cuts->SetMinNClustersITS(2);
  cuts->SetRequireITSRefit(kTRUE);
  cuts->SetRequireTPCRefit(kTRUE);
  cuts->SetMaxDCAToVertexXY(0.3);
  cuts->SetMaxDCAToVertexZ(0.3);
  cuts->SetAcceptKinkDaughters(kFALSE);
  cuts->SetMinimalTPCdedx(10.);

  return cuts;
}

//-----------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts2010()
{
  //get standard cuts
  AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard TPC standalone 2010");
  cuts->SetParamType(kTPCstandalone);
  cuts->SetPtRange(0.2,5.);
  cuts->SetEtaRange(-0.8,0.8);
  cuts->SetMinNClustersTPC(70);
  cuts->SetMinChi2PerClusterTPC(0.2);
  cuts->SetMaxChi2PerClusterTPC(4.0);
  cuts->SetMaxDCAToVertexXY(3.0);
  cuts->SetMaxDCAToVertexZ(3.0);
  cuts->SetDCAToVertex2D(kTRUE);
  cuts->SetAcceptKinkDaughters(kFALSE);
  cuts->SetMinimalTPCdedx(10.);

  return cuts;
}

//-----------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetStandardTPCStandaloneTrackCuts()
{
  //get standard cuts
  AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard TPC standalone");
  cuts->SetParamType(kTPCstandalone);
  cuts->SetPtRange(0.2,5.);
  cuts->SetEtaRange(-0.8,0.8);
  cuts->SetMinNClustersTPC(70);
  cuts->SetMinChi2PerClusterTPC(0.2);
  cuts->SetMaxChi2PerClusterTPC(4.0);
  cuts->SetMaxDCAToVertexXY(3.0);
  cuts->SetMaxDCAToVertexZ(3.0);
  cuts->SetDCAToVertex2D(kTRUE);
  cuts->SetAcceptKinkDaughters(kFALSE);
  cuts->SetMinimalTPCdedx(10.);

  return cuts;
}

//-----------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetStandardITSTPCTrackCuts2009(Bool_t selPrimaries)
{
  //get standard cuts
  AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard global track cuts 2009");
  delete cuts->fAliESDtrackCuts;
  cuts->fAliESDtrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(selPrimaries);
  cuts->SetParamType(kGlobal);
  return cuts;
}

//-----------------------------------------------------------------------------
AliFlowTrackCuts* AliFlowTrackCuts::GetStandardMuonTrackCuts(Bool_t isMC, Int_t passN)
{
// XZhang 20120604
  AliFlowTrackCuts* cuts = new AliFlowTrackCuts("standard muon track cuts");
  cuts->SetParamType(kMUON);
  cuts->SetStandardMuonTrackCuts();
  cuts->SetIsMuonMC(isMC);
  cuts->SetMuonPassNumber(passN);
  return cuts;
}

//-----------------------------------------------------------------------
//AliFlowTrack* AliFlowTrackCuts::FillFlowTrackV0(TObjArray* trackCollection, Int_t trackIndex) const
//{
//  //fill flow track from a reconstructed V0 (topological)
//  AliFlowTrack* flowtrack = static_cast<AliFlowTrack*>(trackCollection->At(trackIndex));
//  if (flowtrack)
//  {
//    flowtrack->Clear();
//  }
//  else 
//  {
//    flowtrack = new AliFlowCandidateTrack();
//    trackCollection->AddAtAndExpand(flowtrack,trackIndex);
//  }
//
//  TParticle *tmpTParticle=NULL;
//  AliMCParticle* tmpAliMCParticle=NULL;
//  AliExternalTrackParam* externalParams=NULL;
//  AliESDtrack* esdtrack=NULL;
//  switch(fParamMix)
//  {
//    case kPure:
//      flowtrack->Set(fTrack);
//      break;
//    case kTrackWithMCkine:
//      flowtrack->Set(fMCparticle);
//      break;
//    case kTrackWithMCPID:
//      flowtrack->Set(fTrack);
//      //flowtrack->setPID(...) from mc, when implemented
//      break;
//    case kTrackWithMCpt:
//      if (!fMCparticle) return NULL;
//      flowtrack->Set(fTrack);
//      flowtrack->SetPt(fMCparticle->Pt());
//      break;
//    case kTrackWithPtFromFirstMother:
//      if (!fMCparticle) return NULL;
//      flowtrack->Set(fTrack);
//      tmpTParticle = fMCparticle->Particle();
//      tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
//      flowtrack->SetPt(tmpAliMCParticle->Pt());
//      break;
//    case kTrackWithTPCInnerParams:
//      esdtrack = dynamic_cast<AliESDtrack*>(fTrack);
//      if (!esdtrack) return NULL;
//      externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam());
//      if (!externalParams) return NULL;
//      flowtrack->Set(externalParams);
//      break;
//    default:
//      flowtrack->Set(fTrack);
//      break;
//  }
//  if (fParamType==kMC) 
//  {
//    flowtrack->SetSource(AliFlowTrack::kFromMC);
//    flowtrack->SetID(fTrackLabel);
//  }
//  else if (dynamic_cast<AliAODTrack*>(fTrack))
//  {
//    if (fParamType==kMUON)                            // XZhang 20120604
//      flowtrack->SetSource(AliFlowTrack::kFromMUON);  // XZhang 20120604
//    else                                              // XZhang 20120604
//      flowtrack->SetSource(AliFlowTrack::kFromAOD);   // XZhang 20120604
//    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
//  }
//  else if (dynamic_cast<AliMCParticle*>(fTrack)) 
//  {
//    flowtrack->SetSource(AliFlowTrack::kFromMC);
//    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
//  }
//
//  if (fV0)
//  {
//    //add daughter indices
//  }
//
//  return flowtrack;
//}

//-----------------------------------------------------------------------
AliFlowTrack* AliFlowTrackCuts::FillFlowTrackKink(TObjArray* trackCollection, Int_t trackIndex) const
{
  //fill flow track from AliVParticle (ESD,AOD,MC)
  AliFlowTrack* flowtrack = static_cast<AliFlowTrack*>(trackCollection->At(trackIndex));
  if (flowtrack)
  {
    flowtrack->Clear();
  }
  else 
  {
    flowtrack = new AliFlowCandidateTrack();
    trackCollection->AddAtAndExpand(flowtrack,trackIndex);
  }

  TParticle *tmpTParticle=NULL;
  AliMCParticle* tmpAliMCParticle=NULL;
  AliExternalTrackParam* externalParams=NULL;
  AliESDtrack* esdtrack=NULL;
  switch(fParamMix)
  {
    case kPure:
      flowtrack->Set(fTrack);
      break;
    case kTrackWithMCkine:
      flowtrack->Set(fMCparticle);
      break;
    case kTrackWithMCPID:
      flowtrack->Set(fTrack);
      //flowtrack->setPID(...) from mc, when implemented
      break;
    case kTrackWithMCpt:
      if (!fMCparticle) return NULL;
      flowtrack->Set(fTrack);
      flowtrack->SetPt(fMCparticle->Pt());
      break;
    case kTrackWithPtFromFirstMother:
      if (!fMCparticle) return NULL;
      flowtrack->Set(fTrack);
      tmpTParticle = fMCparticle->Particle();
      tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
      flowtrack->SetPt(tmpAliMCParticle->Pt());
      break;
    case kTrackWithTPCInnerParams:
      esdtrack = dynamic_cast<AliESDtrack*>(fTrack);
      if (!esdtrack) return NULL;
      externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam());
      if (!externalParams) return NULL;
      flowtrack->Set(externalParams);
      break;
    default:
      flowtrack->Set(fTrack);
      break;
  }
  if (fParamType==kMC) 
  {
    flowtrack->SetSource(AliFlowTrack::kFromMC);
    flowtrack->SetID(fTrackLabel);
  }
  else if (dynamic_cast<AliESDtrack*>(fTrack))
  {
    flowtrack->SetSource(AliFlowTrack::kFromESD);
    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
  }
  else if (dynamic_cast<AliESDMuonTrack*>(fTrack))                                  // XZhang 20120604
  {                                                                                 // XZhang 20120604
    flowtrack->SetSource(AliFlowTrack::kFromMUON);                                  // XZhang 20120604
    flowtrack->SetID((Int_t)static_cast<AliESDMuonTrack*>(fTrack)->GetUniqueID());  // XZhang 20120604
  }                                                                                 // XZhang 20120604
  else if (dynamic_cast<AliAODTrack*>(fTrack))
  {
    if (fParamType==kMUON)                            // XZhang 20120604
      flowtrack->SetSource(AliFlowTrack::kFromMUON);  // XZhang 20120604
    else                                              // XZhang 20120604
      flowtrack->SetSource(AliFlowTrack::kFromAOD);   // XZhang 20120604
    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
  }
  else if (dynamic_cast<AliMCParticle*>(fTrack)) 
  {
    flowtrack->SetSource(AliFlowTrack::kFromMC);
    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
  }

  if (fKink)
  {
    Int_t indexMother = fKink->GetIndex(0);
    Int_t indexDaughter = fKink->GetIndex(1);
    flowtrack->SetID(indexMother);
    flowtrack->AddDaughter(indexDaughter);
    flowtrack->SetMass(1.);
    flowtrack->SetSource(AliFlowTrack::kFromKink);
  }

  flowtrack->SetMass(fTrackMass);

  return flowtrack;
}

//-----------------------------------------------------------------------
AliFlowTrack* AliFlowTrackCuts::FillFlowTrackGeneric(TObjArray* trackCollection, Int_t trackIndex) const
{
  //fill a flow track from tracklet,vzero,pmd,...
  AliFlowTrack* flowtrack = static_cast<AliFlowTrack*>(trackCollection->At(trackIndex));
  if (flowtrack)
  {
    flowtrack->Clear();
  }
  else 
  {
    flowtrack = new AliFlowTrack();
    trackCollection->AddAtAndExpand(flowtrack,trackIndex);
  }
  
  if (FillFlowTrackGeneric(flowtrack)) return flowtrack;
  else 
  {
    trackCollection->RemoveAt(trackIndex);
    delete flowtrack;
    return NULL;
  }
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::FillFlowTrackGeneric(AliFlowTrack* flowtrack) const
{
  //fill a flow track from tracklet,vzero,pmd,...
  TParticle *tmpTParticle=NULL;
  AliMCParticle* tmpAliMCParticle=NULL;
  switch (fParamMix)
  {
    case kPure:
      flowtrack->SetPhi(fTrackPhi);
      flowtrack->SetEta(fTrackEta);
      flowtrack->SetWeight(fTrackWeight);
      flowtrack->SetPt(fTrackPt);
      flowtrack->SetMass(fTrackMass);
      break;
    case kTrackWithMCkine:
      if (!fMCparticle) return kFALSE;
      flowtrack->SetPhi( fMCparticle->Phi() );
      flowtrack->SetEta( fMCparticle->Eta() );
      flowtrack->SetPt( fMCparticle->Pt() );
      flowtrack->SetMass(fTrackMass);
      break;
    case kTrackWithMCpt:
      if (!fMCparticle) return kFALSE;
      flowtrack->SetPhi(fTrackPhi);
      flowtrack->SetEta(fTrackEta);
      flowtrack->SetWeight(fTrackWeight);
      flowtrack->SetPt(fMCparticle->Pt());
      flowtrack->SetMass(fTrackMass);
      break;
    case kTrackWithPtFromFirstMother:
      if (!fMCparticle) return kFALSE;
      flowtrack->SetPhi(fTrackPhi);
      flowtrack->SetEta(fTrackEta);
      flowtrack->SetWeight(fTrackWeight);
      tmpTParticle = fMCparticle->Particle();
      tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
      flowtrack->SetPt(tmpAliMCParticle->Pt());
      flowtrack->SetMass(fTrackMass);
      break;
    default:
      flowtrack->SetPhi(fTrackPhi);
      flowtrack->SetEta(fTrackEta);
      flowtrack->SetWeight(fTrackWeight);
      flowtrack->SetPt(fTrackPt);
      flowtrack->SetMass(fTrackMass);
      break;
  }
  flowtrack->SetSource(AliFlowTrack::kFromTracklet);
  return kTRUE;
}

//-----------------------------------------------------------------------
AliFlowTrack* AliFlowTrackCuts::FillFlowTrackVParticle(TObjArray* trackCollection, Int_t trackIndex) const
{
  //fill flow track from AliVParticle (ESD,AOD,MC)
  
  AliFlowTrack* flowtrack = static_cast<AliFlowTrack*>(trackCollection->At(trackIndex));
  if (flowtrack)
  {
    flowtrack->Clear();
  }
  else 
  {
    flowtrack = new AliFlowTrack();
    trackCollection->AddAtAndExpand(flowtrack,trackIndex);
  }

  if (FillFlowTrackVParticle(flowtrack)) return flowtrack;
  else
  {
    trackCollection->RemoveAt(trackIndex);
    delete flowtrack;
    return NULL;
  }
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::FillFlowTrackVParticle(AliFlowTrack* flowtrack) const
{
  //fill flow track from AliVParticle (ESD,AOD,MC)
  if (!fTrack) return kFALSE;
  TParticle *tmpTParticle=NULL;
  AliMCParticle* tmpAliMCParticle=NULL;
  AliExternalTrackParam* externalParams=NULL;
  AliESDtrack* esdtrack=NULL;
  switch(fParamMix)
  {
    case kPure:
      flowtrack->Set(fTrack);
      break;
    case kTrackWithMCkine:
      flowtrack->Set(fMCparticle);
      break;
    case kTrackWithMCPID:
      flowtrack->Set(fTrack);
      //flowtrack->setPID(...) from mc, when implemented
      break;
    case kTrackWithMCpt:
      if (!fMCparticle) return kFALSE;
      flowtrack->Set(fTrack);
      flowtrack->SetPt(fMCparticle->Pt());
      break;
    case kTrackWithPtFromFirstMother:
      if (!fMCparticle) return kFALSE;
      flowtrack->Set(fTrack);
      tmpTParticle = fMCparticle->Particle();
      tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
      flowtrack->SetPt(tmpAliMCParticle->Pt());
      break;
    case kTrackWithTPCInnerParams:
      esdtrack = dynamic_cast<AliESDtrack*>(fTrack);
      if (!esdtrack) return kFALSE;
      externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam());
      if (!externalParams) return kFALSE;
      flowtrack->Set(externalParams);
      break;
    default:
      flowtrack->Set(fTrack);
      break;
  }
  if (fParamType==kMC) 
  {
    flowtrack->SetSource(AliFlowTrack::kFromMC);
    flowtrack->SetID(fTrackLabel);
  }
  else if (dynamic_cast<AliESDtrack*>(fTrack))
  {
    flowtrack->SetSource(AliFlowTrack::kFromESD);
    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
  }
  else if (dynamic_cast<AliESDMuonTrack*>(fTrack))                                  // XZhang 20120604
  {                                                                                 // XZhang 20120604
    flowtrack->SetSource(AliFlowTrack::kFromMUON);                                  // XZhang 20120604
    flowtrack->SetID((Int_t)static_cast<AliESDMuonTrack*>(fTrack)->GetUniqueID());  // XZhang 20120604
  }                                                                                 // XZhang 20120604
  else if (dynamic_cast<AliAODTrack*>(fTrack))
  {
    if (fParamType==kMUON)                            // XZhang 20120604
      flowtrack->SetSource(AliFlowTrack::kFromMUON);  // XZhang 20120604
    else                                              // XZhang 20120604
      flowtrack->SetSource(AliFlowTrack::kFromAOD);   // XZhang 20120604
    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
  }
  else if (dynamic_cast<AliMCParticle*>(fTrack)) 
  {
    flowtrack->SetSource(AliFlowTrack::kFromMC);
    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
  }
  flowtrack->SetMass(fTrackMass);
  return kTRUE;
}

//-----------------------------------------------------------------------
AliFlowTrack* AliFlowTrackCuts::FillFlowTrack(TObjArray* trackCollection, Int_t trackIndex) const
{
  //fill a flow track constructed from whatever we applied cuts on
  //return true on success
  switch (fParamType)
  {
    case kSPDtracklet:
      return FillFlowTrackGeneric(trackCollection, trackIndex);
    case kPMD:
      return FillFlowTrackGeneric(trackCollection, trackIndex);
    case kVZERO:
      return FillFlowTrackGeneric(trackCollection, trackIndex);
    case kKink:
      return FillFlowTrackKink(trackCollection, trackIndex);
    //case kV0:
    //  return FillFlowTrackV0(trackCollection, trackIndex);
    default:
      return FillFlowTrackVParticle(trackCollection, trackIndex);
  }
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::FillFlowTrack(AliFlowTrack* track) const
{
  //fill a flow track constructed from whatever we applied cuts on
  //return true on success
  switch (fParamType)
  {
    case kSPDtracklet:
      return FillFlowTrackGeneric(track);
    case kPMD:
      return FillFlowTrackGeneric(track);
    case kVZERO:
      return FillFlowTrackGeneric(track);
    default:
      return FillFlowTrackVParticle(track);
  }
}

////-----------------------------------------------------------------------
//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackSPDtracklet() const
//{
//  //make a flow track from tracklet
//  AliFlowTrack* flowtrack=NULL;
//  TParticle *tmpTParticle=NULL;
//  AliMCParticle* tmpAliMCParticle=NULL;
//  switch (fParamMix)
//  {
//    case kPure:
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      break;
//    case kTrackWithMCkine:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi( fMCparticle->Phi() );
//      flowtrack->SetEta( fMCparticle->Eta() );
//      flowtrack->SetPt( fMCparticle->Pt() );
//      break;
//    case kTrackWithMCpt:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      flowtrack->SetPt(fMCparticle->Pt());
//      break;
//    case kTrackWithPtFromFirstMother:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      tmpTParticle = fMCparticle->Particle();
//      tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
//      flowtrack->SetPt(tmpAliMCParticle->Pt());
//      break;
//    default:
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      break;
//  }
//  flowtrack->SetSource(AliFlowTrack::kFromTracklet);
//  return flowtrack;
//}
//
////-----------------------------------------------------------------------
//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackVParticle() const
//{
//  //make flow track from AliVParticle (ESD,AOD,MC)
//  if (!fTrack) return NULL;
//  AliFlowTrack* flowtrack=NULL;
//  TParticle *tmpTParticle=NULL;
//  AliMCParticle* tmpAliMCParticle=NULL;
//  AliExternalTrackParam* externalParams=NULL;
//  AliESDtrack* esdtrack=NULL;
//  switch(fParamMix)
//  {
//    case kPure:
//      flowtrack = new AliFlowTrack(fTrack);
//      break;
//    case kTrackWithMCkine:
//      flowtrack = new AliFlowTrack(fMCparticle);
//      break;
//    case kTrackWithMCPID:
//      flowtrack = new AliFlowTrack(fTrack);
//      //flowtrack->setPID(...) from mc, when implemented
//      break;
//    case kTrackWithMCpt:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack(fTrack);
//      flowtrack->SetPt(fMCparticle->Pt());
//      break;
//    case kTrackWithPtFromFirstMother:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack(fTrack);
//      tmpTParticle = fMCparticle->Particle();
//      tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
//      flowtrack->SetPt(tmpAliMCParticle->Pt());
//      break;
//    case kTrackWithTPCInnerParams:
//      esdtrack = dynamic_cast<AliESDtrack*>(fTrack);
//      if (!esdtrack) return NULL;
//      externalParams = const_cast<AliExternalTrackParam*>(esdtrack->GetTPCInnerParam());
//      if (!externalParams) return NULL;
//      flowtrack = new AliFlowTrack(externalParams);
//      break;
//    default:
//      flowtrack = new AliFlowTrack(fTrack);
//      break;
//  }
//  if (fParamType==kMC) 
//  {
//    flowtrack->SetSource(AliFlowTrack::kFromMC);
//    flowtrack->SetID(fTrackLabel);
//  }
//  else if (dynamic_cast<AliESDtrack*>(fTrack))
//  {
//    flowtrack->SetSource(AliFlowTrack::kFromESD);
//    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
//  }
//  else if (dynamic_cast<AliAODTrack*>(fTrack)) 
//  {
//    flowtrack->SetSource(AliFlowTrack::kFromAOD);
//    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
//  }
//  else if (dynamic_cast<AliMCParticle*>(fTrack)) 
//  {
//    flowtrack->SetSource(AliFlowTrack::kFromMC);
//    flowtrack->SetID(static_cast<AliVTrack*>(fTrack)->GetID());
//  }
//  return flowtrack;
//}
//
////-----------------------------------------------------------------------
//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackPMDtrack() const
//{
//  //make a flow track from PMD track
//  AliFlowTrack* flowtrack=NULL;
//  TParticle *tmpTParticle=NULL;
//  AliMCParticle* tmpAliMCParticle=NULL;
//  switch (fParamMix)
//  {
//    case kPure:
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      break;
//    case kTrackWithMCkine:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi( fMCparticle->Phi() );
//      flowtrack->SetEta( fMCparticle->Eta() );
//      flowtrack->SetWeight(fTrackWeight);
//      flowtrack->SetPt( fMCparticle->Pt() );
//      break;
//    case kTrackWithMCpt:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      flowtrack->SetPt(fMCparticle->Pt());
//      break;
//    case kTrackWithPtFromFirstMother:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      tmpTParticle = fMCparticle->Particle();
//      tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
//      flowtrack->SetPt(tmpAliMCParticle->Pt());
//      break;
//    default:
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      break;
//  }
//
//  flowtrack->SetSource(AliFlowTrack::kFromPMD);
//  return flowtrack;
//}
//
////-----------------------------------------------------------------------
//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrackVZERO() const
//{
//  //make a flow track from VZERO
//  AliFlowTrack* flowtrack=NULL;
//  TParticle *tmpTParticle=NULL;
//  AliMCParticle* tmpAliMCParticle=NULL;
//  switch (fParamMix)
//  {
//    case kPure:
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      break;
//    case kTrackWithMCkine:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi( fMCparticle->Phi() );
//      flowtrack->SetEta( fMCparticle->Eta() );
//      flowtrack->SetWeight(fTrackWeight);
//      flowtrack->SetPt( fMCparticle->Pt() );
//      break;
//    case kTrackWithMCpt:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      flowtrack->SetPt(fMCparticle->Pt());
//      break;
//    case kTrackWithPtFromFirstMother:
//      if (!fMCparticle) return NULL;
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      tmpTParticle = fMCparticle->Particle();
//      tmpAliMCParticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(tmpTParticle->GetFirstMother()));
//      flowtrack->SetPt(tmpAliMCParticle->Pt());
//      break;
//    default:
//      flowtrack = new AliFlowTrack();
//      flowtrack->SetPhi(fTrackPhi);
//      flowtrack->SetEta(fTrackEta);
//      flowtrack->SetWeight(fTrackWeight);
//      break;
//  }
//
//  flowtrack->SetSource(AliFlowTrack::kFromVZERO);
//  return flowtrack;
//}
//
////-----------------------------------------------------------------------
//AliFlowTrack* AliFlowTrackCuts::MakeFlowTrack() const
//{
//  //get a flow track constructed from whatever we applied cuts on
//  //caller is resposible for deletion
//  //if construction fails return NULL
//  //TODO: for tracklets, PMD and VZERO we probably need just one method,
//  //something like MakeFlowTrackGeneric(), wait with this until
//  //requirements quirks are known.
//  switch (fParamType)
//  {
//    case kSPDtracklet:
//      return MakeFlowTrackSPDtracklet();
//    case kPMD:
//      return MakeFlowTrackPMDtrack();
//    case kVZERO:
//      return MakeFlowTrackVZERO();
//    default:
//      return MakeFlowTrackVParticle();
//  }
//}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::IsPhysicalPrimary() const
{
  //check if current particle is a physical primary
  if (!fMCevent) return kFALSE;
  if (fTrackLabel<0) return kFALSE;
  return IsPhysicalPrimary(fMCevent, fTrackLabel, fRequireTransportBitForPrimaries);
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::IsPhysicalPrimary(AliMCEvent* mcEvent, Int_t label, Bool_t requiretransported)
{
  //check if current particle is a physical primary
  Bool_t physprim=mcEvent->IsPhysicalPrimary(label);
  AliMCParticle* track = static_cast<AliMCParticle*>(mcEvent->GetTrack(label));
  if (!track) return kFALSE;
  TParticle* particle = track->Particle();
  Bool_t transported = particle->TestBit(kTransportBit);
  //printf("label: %i prim: %s, transp: %s, pass: %s\n",label, (physprim)?"YES":"NO ",(transported)?"YES":"NO ",
        //(physprim && (transported || !requiretransported))?"YES":"NO"  );
  return (physprim && (transported || !requiretransported));
}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::DefineHistograms()
{
  //define qa histograms
  if (fQA) return;
  
  const Int_t kNbinsP=200;
  Double_t binsP[kNbinsP+1];
  binsP[0]=0.0;
  for(int i=1; i<kNbinsP+1; i++)
  {
    //if(binsP[i-1]+0.05<1.01)
    //  binsP[i]=binsP[i-1]+0.05;
    //else
    binsP[i]=binsP[i-1]+0.05;
  }

  const Int_t nBinsDCA=1000;
  Double_t binsDCA[nBinsDCA+1];
  for(int i=0; i<nBinsDCA+1; i++) {binsDCA[i]=0.01*i-5.;}
  //for(int i=1; i<41; i++) {binsDCA[i+100]=0.1*i+1.0;}

  Bool_t adddirstatus = TH1::AddDirectoryStatus();
  TH1::AddDirectory(kFALSE);
  fQA=new TList(); fQA->SetOwner();
  fQA->SetName(Form("%s QA",GetName()));
  TList* before = new TList(); before->SetOwner();
  before->SetName("before");
  TList* after = new TList(); after->SetOwner();
  after->SetName("after");
  fQA->Add(before);
  fQA->Add(after);
  before->Add(new TH2F("TOFbeta",";p [GeV/c];#beta",kNbinsP,binsP,1000,0.4,1.1)); //0
  after->Add(new TH2F("TOFbeta",";p [GeV/c];#beta",kNbinsP,binsP,1000,0.4,1.1)); //0
  before->Add(new TH2F("TPCdedx",";p [GeV/c];dEdx",kNbinsP,binsP,500,0,500)); //1
  after->Add(new TH2F("TPCdedx",";p [GeV/c];dEdx",kNbinsP,binsP,500,0,500)); //1
  before->Add(new TH2F("MC pid",";p[GeV/c];species",kNbinsP,binsP,10,-5, 5)); //2
  after->Add(new TH2F("MC pid",";p[GeV/c];species",kNbinsP,binsP,10,-5, 5)); //2
  //primary
  TH2F* hb = new TH2F("MC primary",";p[GeV/c];primary",kNbinsP,binsP,2,-1,1);
  TH2F* ha = new TH2F("MC primary",";p[GeV/c];primary",kNbinsP,binsP,2,-1,1);
  TAxis* axis = NULL;
  axis = hb->GetYaxis(); 
  axis->SetBinLabel(1,"secondary");
  axis->SetBinLabel(2,"primary");
  axis = ha->GetYaxis(); 
  axis->SetBinLabel(1,"secondary");
  axis->SetBinLabel(2,"primary");
  before->Add(hb); //3
  after->Add(ha); //3
  //production process
  hb = new TH2F("MC production process",";p[GeV/c];",kNbinsP,binsP,kMaxMCProcess,
                      -0.5, kMaxMCProcess-0.5);
  ha = new TH2F("MC production process",";p[GeV/c];",kNbinsP,binsP,kMaxMCProcess,
                      -0.5, kMaxMCProcess-0.5);
  axis = hb->GetYaxis();
  for (Int_t i=0; i<kMaxMCProcess; i++)
  {
    axis->SetBinLabel(i+1,TMCProcessName[i]);
  }
  axis = ha->GetYaxis();
  for (Int_t i=0; i<kMaxMCProcess; i++)
  {
    axis->SetBinLabel(i+1,TMCProcessName[i]);
  }
  before->Add(hb); //4
  after->Add(ha); //4
  //DCA
  before->Add(new TH2F("DCAxy",";p_{t}[GeV/c];DCAxy[cm]", 100, 0., 10., nBinsDCA, binsDCA));//5
  after->Add(new TH2F("DCAxy",";p_{t}[GeV/c];DCAxy[cm]", 100, 0., 10., nBinsDCA, binsDCA));//5
  before->Add(new TH2F("DCAz",";p_{t}[GeV/c];DCAz[cm]", 100, 0., 10., nBinsDCA, binsDCA));//6
  after->Add(new TH2F("DCAz",";p_{t}[GeV/c];DCAz[cm]", 100, 0., 10., nBinsDCA, binsDCA));//6
  //first mother
  hb = new TH2F("MC first mother",";p[GeV/c];",kNbinsP,binsP,44,1.,45.);
  ha = new TH2F("MC first mother",";p[GeV/c];",kNbinsP,binsP,44,1.,45.);
  hb->GetYaxis()->SetBinLabel(1, "#gamma");
  ha->GetYaxis()->SetBinLabel(1, "#gamma");
  hb->GetYaxis()->SetBinLabel(2, "e^{+}");
  ha->GetYaxis()->SetBinLabel(2, "e^{+}");
  hb->GetYaxis()->SetBinLabel(3, "e^{-}");
  ha->GetYaxis()->SetBinLabel(3, "e^{-}");
  hb->GetYaxis()->SetBinLabel(4, "#nu");
  ha->GetYaxis()->SetBinLabel(4, "#nu");
  hb->GetYaxis()->SetBinLabel(5, "#mu^{+}");
  ha->GetYaxis()->SetBinLabel(5, "#mu^{+}");
  hb->GetYaxis()->SetBinLabel(6, "#mu^{-}");
  ha->GetYaxis()->SetBinLabel(6, "#mu^{-}");
  hb->GetYaxis()->SetBinLabel(7, "#pi^{0}");
  ha->GetYaxis()->SetBinLabel(7, "#pi^{0}");
  hb->GetYaxis()->SetBinLabel(8, "#pi^{+}");
  ha->GetYaxis()->SetBinLabel(8, "#pi^{+}");
  hb->GetYaxis()->SetBinLabel(9, "#pi^{-}");
  ha->GetYaxis()->SetBinLabel(9, "#pi^{-}");
  hb->GetYaxis()->SetBinLabel(10, "K^{0}_{L}");
  ha->GetYaxis()->SetBinLabel(10, "K^{0}_{L}");
  hb->GetYaxis()->SetBinLabel(11, "K^{+}");
  ha->GetYaxis()->SetBinLabel(11, "K^{+}");
  hb->GetYaxis()->SetBinLabel(12, "K^{-}");
  ha->GetYaxis()->SetBinLabel(12, "K^{-}");
  hb->GetYaxis()->SetBinLabel( 13, "n");
  ha->GetYaxis()->SetBinLabel( 13, "n");
  hb->GetYaxis()->SetBinLabel( 14, "p");
  ha->GetYaxis()->SetBinLabel( 14, "p");
  hb->GetYaxis()->SetBinLabel(15, "#bar{p}");
  ha->GetYaxis()->SetBinLabel(15, "#bar{p}");
  hb->GetYaxis()->SetBinLabel(16, "K^{0}_{S}");
  ha->GetYaxis()->SetBinLabel(16, "K^{0}_{S}");
  hb->GetYaxis()->SetBinLabel(17, "#eta");
  ha->GetYaxis()->SetBinLabel(17, "#eta");
  hb->GetYaxis()->SetBinLabel(18, "#Lambda");
  ha->GetYaxis()->SetBinLabel(18, "#Lambda");
  hb->GetYaxis()->SetBinLabel(19, "#Sigma^{+}");
  ha->GetYaxis()->SetBinLabel(19, "#Sigma^{+}");
  hb->GetYaxis()->SetBinLabel(20, "#Sigma^{0}");
  ha->GetYaxis()->SetBinLabel(20, "#Sigma^{0}");
  hb->GetYaxis()->SetBinLabel(21, "#Sigma^{-}");
  ha->GetYaxis()->SetBinLabel(21, "#Sigma^{-}");
  hb->GetYaxis()->SetBinLabel(22, "#Theta^{0}");
  ha->GetYaxis()->SetBinLabel(22, "#Theta^{0}");
  hb->GetYaxis()->SetBinLabel(23, "#Theta^{-}");
  ha->GetYaxis()->SetBinLabel(23, "#Theta^{-}");
  hb->GetYaxis()->SetBinLabel(24, "#Omega^{-}");
  ha->GetYaxis()->SetBinLabel(24, "#Omega^{-}");
  hb->GetYaxis()->SetBinLabel(25, "#bar{n}");
  ha->GetYaxis()->SetBinLabel(25, "#bar{n}");
  hb->GetYaxis()->SetBinLabel(26, "#bar{#Lambda}");
  ha->GetYaxis()->SetBinLabel(26, "#bar{#Lambda}");
  hb->GetYaxis()->SetBinLabel(27, "#bar{#Sigma}^{-}");
  ha->GetYaxis()->SetBinLabel(27, "#bar{#Sigma}^{-}");
  hb->GetYaxis()->SetBinLabel(28, "#bar{#Sigma}^{0}");
  ha->GetYaxis()->SetBinLabel(28, "#bar{#Sigma}^{0}");
  hb->GetYaxis()->SetBinLabel(29, "#bar{#Sigma}^{+}");
  ha->GetYaxis()->SetBinLabel(29, "#bar{#Sigma}^{+}");
  hb->GetYaxis()->SetBinLabel(30, "#bar{#Theta}^{0}");
  ha->GetYaxis()->SetBinLabel(30, "#bar{#Theta}^{0}");
  hb->GetYaxis()->SetBinLabel(31, "#bar{#Theta}^{+}");
  ha->GetYaxis()->SetBinLabel(31, "#bar{#Theta}^{+}");
  hb->GetYaxis()->SetBinLabel(32, "#bar{#Omega}^{+}");
  ha->GetYaxis()->SetBinLabel(32, "#bar{#Omega}^{+}");
  hb->GetYaxis()->SetBinLabel(33, "#tau^{+}");
  ha->GetYaxis()->SetBinLabel(33, "#tau^{+}");
  hb->GetYaxis()->SetBinLabel(34, "#tau^{-}");
  ha->GetYaxis()->SetBinLabel(34, "#tau^{-}");
  hb->GetYaxis()->SetBinLabel(35, "D^{+}");
  ha->GetYaxis()->SetBinLabel(35, "D^{+}");
  hb->GetYaxis()->SetBinLabel(36, "D^{-}");
  ha->GetYaxis()->SetBinLabel(36, "D^{-}");
  hb->GetYaxis()->SetBinLabel(37, "D^{0}");
  ha->GetYaxis()->SetBinLabel(37, "D^{0}");
  hb->GetYaxis()->SetBinLabel(38, "#bar{D}^{0}");
  ha->GetYaxis()->SetBinLabel(38, "#bar{D}^{0}");
  hb->GetYaxis()->SetBinLabel(39, "D_{s}^{+}");
  ha->GetYaxis()->SetBinLabel(39, "D_{s}^{+}");
  hb->GetYaxis()->SetBinLabel(40, "#bar{D_{s}}^{-}");
  ha->GetYaxis()->SetBinLabel(40, "#bar{D_{s}}^{-}");
  hb->GetYaxis()->SetBinLabel(41, "#Lambda_{c}^{+}");
  ha->GetYaxis()->SetBinLabel(41, "#Lambda_{c}^{+}");
  hb->GetYaxis()->SetBinLabel(42, "W^{+}");
  ha->GetYaxis()->SetBinLabel(42, "W^{+}");
  hb->GetYaxis()->SetBinLabel(43, "W^{-}");
  ha->GetYaxis()->SetBinLabel(43, "W^{-}");
  hb->GetYaxis()->SetBinLabel(44, "Z^{0}");
  ha->GetYaxis()->SetBinLabel(44, "Z^{0}");
  before->Add(hb);//7
  after->Add(ha);//7

  before->Add(new TH2F("TOFkElectron",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//8
  after->Add( new TH2F("TOFkElectron",";p_{t}[GeV/c];TOF signal - IT", kNbinsP,binsP,1000,-2e4, 2e4));//8

  before->Add(new TH2F("TOFkMuon",";p_{t}[GeV/c];TOF signal - IT",     kNbinsP,binsP,1000,-2e4, 2e4));//9
  after->Add( new TH2F("TOFkMuon",";p_{t}[GeV/c];TOF signal - IT",     kNbinsP,binsP,1000,-2e4, 2e4));//9

  before->Add(new TH2F("TOFkPion",";p_{t}[GeV/c];TOF signal - IT",     kNbinsP,binsP,1000,-2e4, 2e4));//10
  after->Add( new TH2F("TOFkPion",";p_{t}[GeV/c];TOF signal - IT",     kNbinsP,binsP,1000,-2e4, 2e4));//10

  before->Add(new TH2F("TOFkKaon",";p_{t}[GeV/c];TOF signal - IT",     kNbinsP,binsP,1000,-2e4, 2e4));//11
  after->Add( new TH2F("TOFkKaon",";p_{t}[GeV/c];TOF signal - IT",     kNbinsP,binsP,1000,-2e4, 2e4));//11

  before->Add(new TH2F("TOFkProton",";p_{t}[GeV/c];TOF signal - IT",   kNbinsP,binsP,1000,-2e4, 2e4));//12
  after->Add( new TH2F("TOFkProton",";p_{t}[GeV/c];TOF signal - IT",   kNbinsP,binsP,1000,-2e4, 2e4));//12

  //kink stuff
  before->Add(new TH1F("KinkQt",";q_{t}[GeV/c];counts", 200, 0., 0.3));//13
  after->Add(new TH1F("KinkQt",";q_{t}[GeV/c];counts", 200, 0., 0.3));//13

  before->Add(new TH1F("KinkMinv",";m_{inv}(#mu#nu)[GeV/c^{2}];counts;Kink M_{inv}", 200, 0., 0.7));//14
  after->Add(new TH1F("KinkMinv",";m_{inv}(#mu#nu)[GeV/c^{2}];counts;Kink M_{inv}", 200, 0., 0.7));//14

  before->Add(new TH2F("KinkVertex",";x[cm];y[cm];Kink vertex position",250,-250.,250., 250,-250.,250.));//15
  after->Add(new TH2F("KinkVertex",";x[cm];y[cm];Kink vertex position",250,-250.,250., 250,-250.,250.));//15

  before->Add(new TH2F("KinkAngleMp",";p_{mother}[GeV/c];Kink decay angle [deg];", 100,0.,6., 100,0.,80.));//16
  after->Add(new TH2F("KinkAngleMp",";p_{mother}[GeV/c];Kink decay angle [deg];", 100,0.,6., 100,0.,80.));//16

  before->Add(new TH1F("KinkIndex",";Kink index;counts", 2, 0., 2.));//17
  after->Add(new TH1F("KinkIndex",";Kink index;counts", 2, 0., 2.));//17
  TH1::AddDirectory(adddirstatus);
}

//-----------------------------------------------------------------------
Int_t AliFlowTrackCuts::GetNumberOfInputObjects() const
{
  //get the number of tracks in the input event according source
  //selection (ESD tracks, tracklets, MC particles etc.)
  AliESDEvent* esd=NULL;
  AliAODEvent* aod=NULL;  // XZhang 20120615
  switch (fParamType)
  {
    case kSPDtracklet:
      if (!fEvent) return 0;                                           // XZhang 20120615
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      aod = dynamic_cast<AliAODEvent*>(fEvent);                        // XZhang 20120615
//    if (!esd) return 0;                                              // XZhang 20120615
//    return esd->GetMultiplicity()->GetNumberOfTracklets();           // XZhang 20120615
      if (esd) return esd->GetMultiplicity()->GetNumberOfTracklets();  // XZhang 20120615
      if (aod) return aod->GetTracklets()->GetNumberOfTracklets();     // XZhang 20120615
    case kMC:
      if (!fMCevent) return 0;
      return fMCevent->GetNumberOfTracks();
    case kPMD:
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      if (!esd) return 0;
      return esd->GetNumberOfPmdTracks();
    case kVZERO:
      return fgkNumberOfVZEROtracks;
    case kMUON:                                      // XZhang 20120604
      if (!fEvent) return 0;                         // XZhang 20120604
      esd = dynamic_cast<AliESDEvent*>(fEvent);      // XZhang 20120604
      if (esd) return esd->GetNumberOfMuonTracks();  // XZhang 20120604
      return fEvent->GetNumberOfTracks();  // if AOD // XZhang 20120604
    case kKink:
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      if (!esd) return 0;
      return esd->GetNumberOfKinks();
    case kV0:
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      if (!esd) return 0;
      return esd->GetNumberOfV0s();
    default:
      if (!fEvent) return 0;
      return fEvent->GetNumberOfTracks();
  }
  return 0;
}

//-----------------------------------------------------------------------
TObject* AliFlowTrackCuts::GetInputObject(Int_t i)
{
  //get the input object according the data source selection:
  //(esd tracks, traclets, mc particles,etc...)
  AliESDEvent* esd=NULL;
  AliAODEvent* aod=NULL;  // XZhang 20120615
  switch (fParamType)
  {
    case kSPDtracklet:
      if (!fEvent) return NULL;                                              // XZhang 20120615
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      aod = dynamic_cast<AliAODEvent*>(fEvent);                              // XZhang 20120615
//    if (!esd) return NULL;                                                 // XZhang 20120615
//    return const_cast<AliMultiplicity*>(esd->GetMultiplicity());           // XZhang 20120615
      if (esd) return const_cast<AliMultiplicity*>(esd->GetMultiplicity());  // XZhang 20120615
      if (aod) return const_cast<AliAODTracklets*>(aod->GetTracklets());     // XZhang 20120615
    case kMC:
      if (!fMCevent) return NULL;
      return fMCevent->GetTrack(i);
    case kPMD:
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      if (!esd) return NULL;
      return esd->GetPmdTrack(i);
    case kVZERO:
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      if (!esd) //contributed by G.Ortona
      {
        aod = dynamic_cast<AliAODEvent*>(fEvent);
        if(!aod)return NULL;
        return aod->GetVZEROData();
      }
      return esd->GetVZEROData();
    case kMUON:                                  // XZhang 20120604
      if (!fEvent) return NULL;                  // XZhang 20120604
      esd = dynamic_cast<AliESDEvent*>(fEvent);  // XZhang 20120604
      if (esd) return esd->GetMuonTrack(i);      // XZhang 20120604
      return fEvent->GetTrack(i);  // if AOD     // XZhang 20120604
    case kKink:
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      if (!esd) return NULL;
      return esd->GetKink(i);
    case kV0:
      esd = dynamic_cast<AliESDEvent*>(fEvent);
      if (!esd) return NULL;
      return esd->GetV0(i);
    default:
      if (!fEvent) return NULL;
      return fEvent->GetTrack(i);
  }
}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::Clear(Option_t*)
{
  //clean up
  fMCevent=NULL;
  fEvent=NULL;
  ClearTrack();
}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::ClearTrack(Option_t*)
{
  //clean up last track
  fKink=NULL;
  fV0=NULL;
  fTrack=NULL;
  fMCparticle=NULL;
  fTrackLabel=-997;
  fTrackWeight=1.0;
  fTrackEta=0.0;
  fTrackPhi=0.0;
  fTrackPt=0.0;
  fPOItype=1;
  fTrackMass=0.;
}
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesAODpidCut(const AliAODTrack* track )
{
     if(!track->GetAODEvent()->GetTOFHeader()){
          AliAODPid *pidObj = track->GetDetPid();
          if (!pidObj) fESDpid.GetTOFResponse().SetTimeResolution(84.);
          else{
            Double_t sigmaTOFPidInAOD[10];
            pidObj->GetTOFpidResolution(sigmaTOFPidInAOD);
            if(sigmaTOFPidInAOD[0] > 84.){
              fESDpid.GetTOFResponse().SetTimeResolution(sigmaTOFPidInAOD[0]); // use the electron TOF PID sigma as time resolution (including the T0 used)
          }
        }
     }

 //check if passes the selected pid cut for ESDs
  Bool_t pass = kTRUE;
  switch (fPIDsource)
  {
   case kTOFbeta:
      if (!PassesTOFbetaCut(track)) pass=kFALSE;
      break;
  case kTOFbayesian:
      if (!PassesTOFbayesianCut(track)) pass=kFALSE;
      break;
  case kTPCbayesian:
      if (!PassesTPCbayesianCut(track)) pass=kFALSE;
      break;
  case kTPCTOFNsigma:
      if (!PassesTPCTOFNsigmaCut(track)) pass = kFALSE;
      break;
  default:
    return kTRUE;
    break;
 }
  return pass;

}
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesESDpidCut(const AliESDtrack* track )
{
  //check if passes the selected pid cut for ESDs
  Bool_t pass = kTRUE; 
  switch (fPIDsource)    
  {
    case kTPCpid:
      if (!PassesTPCpidCut(track)) pass=kFALSE;
      break;
    case kTPCdedx:
      if (!PassesTPCdedxCut(track)) pass=kFALSE;
      break;
    case kTOFpid:
      if (!PassesTOFpidCut(track)) pass=kFALSE;
      break;
    case kTOFbeta:
      if (!PassesTOFbetaCut(track)) pass=kFALSE;
      break;
    case kTOFbetaSimple:
      if (!PassesTOFbetaSimpleCut(track)) pass=kFALSE;
      break;
    case kTPCbayesian:
      if (!PassesTPCbayesianCut(track)) pass=kFALSE;
      break;
      // part added by F. Noferini
    case kTOFbayesian:
      if (!PassesTOFbayesianCut(track)) pass=kFALSE;
      break;
      // end part added by F. Noferini

      //part added by Natasha
    case kTPCNuclei:
      if (!PassesNucleiSelection(track)) pass=kFALSE;
      break;
      //end part added by Natasha
      
    case kTPCTOFNsigma:
      if (!PassesTPCTOFNsigmaCut(track)) pass = kFALSE;
      break;
    default:
      printf("AliFlowTrackCuts::PassesCuts() this should never be called!\n");
      pass=kFALSE;
      break;
  }
  return pass;
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTOFbetaSimpleCut(const AliESDtrack* track )
{
  //check if passes PID cut using timing in TOF
  Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) &&
                     (track->GetTOFsignal() > 12000) && 
                     (track->GetTOFsignal() < 100000) && 
                     (track->GetIntegratedLength() > 365);
                    
  if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;}

  Bool_t statusMatchingHard = TPCTOFagree(track);
  if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
       return kFALSE;

  if (!goodtrack) return kFALSE;
  
  const Float_t c = 2.99792457999999984e-02;  
  Float_t p = track->GetP();
  Float_t l = track->GetIntegratedLength();  
  Float_t trackT0 = fESDpid.GetTOFResponse().GetStartTime(p);
  Float_t timeTOF = track->GetTOFsignal()- trackT0; 
  Float_t beta = l/timeTOF/c;
  Double_t integratedTimes[9] = {-1.0,-1.0,-1.0,-1.0,-1.0, -1.0, -1.0, -1.0, -1.0};
  track->GetIntegratedTimes(integratedTimes);
  Float_t betaHypothesis[5] = {0.0,0.0,0.0,0.0,0.0};
  Float_t s[5] = {0.0,0.0,0.0,0.0,0.0};
  for (Int_t i=0;i<5;i++)
  {
    betaHypothesis[i] = l/integratedTimes[i]/c;
    s[i] = beta-betaHypothesis[i];
  }

  switch (fParticleID)
  {
    case AliPID::kPion:
      return ( (s[2]<0.015) && (s[2]>-0.015) &&
               (s[3]>0.025) &&
               (s[4]>0.03) );
    case AliPID::kKaon:
      return ( (s[3]<0.015) && (s[3]>-0.015) &&
               (s[2]<-0.03) &&
               (s[4]>0.03) );
    case AliPID::kProton:
      return ( (s[4]<0.015) && (s[4]>-0.015) &&
               (s[3]<-0.025) &&
               (s[2]<-0.025) );
    default:
      return kFALSE;
  }
  return kFALSE;
}

//-----------------------------------------------------------------------
Float_t AliFlowTrackCuts::GetBeta(const AliVTrack* track, Bool_t QAmode)
{
  //get beta
  Double_t integratedTimes[9] = {-1.0,-1.0,-1.0,-1.0,-1.0, -1.0, -1.0, -1.0, -1.0};
  track->GetIntegratedTimes(integratedTimes);

  const Float_t c = 2.99792457999999984e-02;  
  Float_t p = track->P();
  Float_t l = integratedTimes[0]*c;  
  Float_t trackT0 = fESDpid.GetTOFResponse().GetStartTime(p);
  Float_t timeTOF = track->GetTOFsignal()- trackT0; 
  if(QAmode && timeTOF <= 0) return -999;   // avoid division by zero when filling 'before' qa histograms
  return l/timeTOF/c;
}
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTOFbetaCut(const AliAODTrack* track )
{
  //check if track passes pid selection with an asymmetric TOF beta cut
  if (!fTOFpidCuts)
  {
    //printf("no TOFpidCuts\n");
    return kFALSE;
  }

  //check if passes PID cut using timing in TOF
  Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) &&
                     (track->GetTOFsignal() > 12000) &&
                     (track->GetTOFsignal() < 100000);

  if (!goodtrack) return kFALSE;

  const Float_t c = 2.99792457999999984e-02;
  Double_t integratedTimes[9] = {-1.0,-1.0,-1.0,-1.0,-1.0, -1.0, -1.0, -1.0, -1.0};
  track->GetIntegratedTimes(integratedTimes);
  Float_t l = integratedTimes[0]*c;

  goodtrack = goodtrack && (l > 365);

  if (!goodtrack) return kFALSE;

  if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;}

  Bool_t statusMatchingHard = TPCTOFagree(track);
  if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
       return kFALSE;


  Float_t beta = GetBeta(track);

  //construct the pid index because it's not AliPID::EParticleType
  Int_t pid = 0;
  switch (fParticleID)
  {
    case AliPID::kPion:
      pid=2;
      break;
    case AliPID::kKaon:
      pid=3;
      break;
    case AliPID::kProton:
      pid=4;
      break;
    default:
      return kFALSE;
  }

  //signal to cut on
  Float_t p = track->P();
  Float_t betahypothesis = l/integratedTimes[pid]/c;
  Float_t betadiff = beta-betahypothesis;

  Float_t* arr = fTOFpidCuts->GetMatrixArray();
  Int_t col = TMath::BinarySearch(fTOFpidCuts->GetNcols(),arr,static_cast<Float_t>(p));
  if (col<0) return kFALSE;
  Float_t min = (*fTOFpidCuts)(1,col);
  Float_t max = (*fTOFpidCuts)(2,col);

  Bool_t pass = (betadiff>min && betadiff<max);

  return pass;
}
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTOFbetaCut(const AliESDtrack* track )
{
  //check if track passes pid selection with an asymmetric TOF beta cut
  if (!fTOFpidCuts)
  {
    //printf("no TOFpidCuts\n");
    return kFALSE;
  }

  //check if passes PID cut using timing in TOF
  Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFpid) && 
                     (track->GetTOFsignal() > 12000) && 
                     (track->GetTOFsignal() < 100000) && 
                     (track->GetIntegratedLength() > 365);

  if (!fAllowTOFmismatchFlag) {if ((track->GetStatus() & AliESDtrack::kTOFmismatch)) return kFALSE;}

  if (!goodtrack) return kFALSE;

  Bool_t statusMatchingHard = TPCTOFagree(track);
  if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
       return kFALSE;
  
  Float_t beta = GetBeta(track);
  Double_t integratedTimes[9] = {-1.0,-1.0,-1.0,-1.0,-1.0, -1.0, -1.0, -1.0, -1.0};
  track->GetIntegratedTimes(integratedTimes);

  //construct the pid index because it's not AliPID::EParticleType
  Int_t pid = 0;
  switch (fParticleID)
  {
    case AliPID::kPion:
      pid=2;
      break;
    case AliPID::kKaon:
      pid=3;
      break;
    case AliPID::kProton:
      pid=4;
      break;
    default:
      return kFALSE;
  }

  //signal to cut on
  const Float_t c = 2.99792457999999984e-02;  
  Float_t l = track->GetIntegratedLength();  
  Float_t p = track->GetP();  
  Float_t betahypothesis = l/integratedTimes[pid]/c;
  Float_t betadiff = beta-betahypothesis;

  Float_t* arr = fTOFpidCuts->GetMatrixArray();
  Int_t col = TMath::BinarySearch(fTOFpidCuts->GetNcols(),arr,static_cast<Float_t>(p));
  if (col<0) return kFALSE;
  Float_t min = (*fTOFpidCuts)(1,col);
  Float_t max = (*fTOFpidCuts)(2,col);

  Bool_t pass = (betadiff>min && betadiff<max);
  
  return pass;
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTOFpidCut(const AliESDtrack* track) const
{
  //check if passes PID cut using default TOF pid
  Double_t pidTOF[AliPID::kSPECIES];
  track->GetTOFpid(pidTOF);
  if (pidTOF[fParticleID]>=fParticleProbability) return kTRUE;
  return kFALSE;
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTPCpidCut(const AliESDtrack* track) const
{
  //check if passes PID cut using default TPC pid
  Double_t pidTPC[AliPID::kSPECIES];
  track->GetTPCpid(pidTPC);
  Double_t probablity = 0.;
  switch (fParticleID)
  {
    case AliPID::kPion:
      probablity = pidTPC[AliPID::kPion] + pidTPC[AliPID::kMuon];
      break;
    default:
      probablity = pidTPC[fParticleID];
  }
  if (probablity >= fParticleProbability) return kTRUE;
  return kFALSE;
}

//-----------------------------------------------------------------------
Float_t AliFlowTrackCuts::Getdedx(const AliESDtrack* track) const
{
  //get TPC dedx
  return track->GetTPCsignal();
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTPCdedxCut(const AliESDtrack* track)
{
  //check if passes PID cut using dedx signal in the TPC
  if (!fTPCpidCuts)
  {
    //printf("no TPCpidCuts\n");
    return kFALSE;
  }

  const AliExternalTrackParam* tpcparam = track->GetInnerParam(); //tpc only params at the inner wall
  if (!tpcparam) return kFALSE;
  Double_t p = tpcparam->GetP();
  Float_t sigExp = fESDpid.GetTPCResponse().GetExpectedSignal(p, fParticleID);
  Float_t sigTPC = track->GetTPCsignal();
  Float_t s = (sigTPC-sigExp)/sigExp;

  Float_t* arr = fTPCpidCuts->GetMatrixArray();
  Int_t arrSize = fTPCpidCuts->GetNcols();
  Int_t col = TMath::BinarySearch( arrSize, arr, static_cast<Float_t>(p));
  if (col<0) return kFALSE;
  Float_t min = (*fTPCpidCuts)(1,col);
  Float_t max = (*fTPCpidCuts)(2,col);

  //printf("------------TPC pid cut %s\n",(s>min && s<max)?"PASS":"FAIL");
  return (s>min && s<max);
}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::InitPIDcuts()
{
  //init matrices with PID cuts
  TMatrixF* t = NULL;
  if (!fTPCpidCuts)
  {
    if (fParticleID==AliPID::kPion)
    {
      t = new TMatrixF(3,15);
      (*t)(0,0)  = 0.20;  (*t)(1,0)  = -0.4;  (*t)(2,0)  =   0.0;
      (*t)(0,1)  = 0.25;  (*t)(1,1)  = -0.4;  (*t)(2,1)  =   0.1;
      (*t)(0,2)  = 0.30;  (*t)(1,2)  = -0.4;  (*t)(2,2)  =  0.2;
      (*t)(0,3)  = 0.35;  (*t)(1,3)  = -0.4;  (*t)(2,3)  =  0.2;
      (*t)(0,4)  = 0.40;  (*t)(1,4)  = -0.4;  (*t)(2,4)  =   0.3;
      (*t)(0,5)  = 0.45;  (*t)(1,5)  = -0.4;  (*t)(2,5)  =   0.3;
      (*t)(0,6)  = 0.50;  (*t)(1,6)  = -0.4;  (*t)(2,6)  =  0.25;
      (*t)(0,7)  = 0.55;  (*t)(1,7)  = -0.4;  (*t)(2,7)  =  0.15;
      (*t)(0,8)  = 0.60;  (*t)(1,8)  = -0.4;  (*t)(2,8)  =   0.1;
      (*t)(0,9)  = 0.65;  (*t)(1,9)  = -0.4;  (*t)(2,9)  =  0.05;
      (*t)(0,10)  = 0.70;  (*t)(1,10)  = -0.4;  (*t)(2,10)  =     0;
      (*t)(0,11)  = 0.75;  (*t)(1,11)  = -0.4;  (*t)(2,11)  =     0;
      (*t)(0,12)  = 0.80;  (*t)(1,12)  = -0.4;  (*t)(2,12)  = -0.05;
      (*t)(0,13)  = 0.85;  (*t)(1,13)  = -0.4;  (*t)(2,13)  = -0.1;
      (*t)(0,14)  = 0.90;  (*t)(1,14)  = 0;     (*t)(2,14)  =     0;
    }
    else
    if (fParticleID==AliPID::kKaon)
    {
      t = new TMatrixF(3,12);
      (*t)(0,0)  = 0.20;  (*t)(1,0)  = -0.2;  (*t)(2,0)  = 0.2; 
      (*t)(0,1)  = 0.25;  (*t)(1,1)  = -0.2;  (*t)(2,1)  = 0.2;
      (*t)(0,2)  = 0.30;  (*t)(1,2)  = -0.2;  (*t)(2,2)  = 0.2;
      (*t)(0,3)  = 0.35;  (*t)(1,3)  = -0.2;  (*t)(2,3)  = 0.2;
      (*t)(0,4)  = 0.40;  (*t)(1,4)  = -0.1;  (*t)(2,4)  = 0.2;
      (*t)(0,5)  = 0.45;  (*t)(1,5)  = -0.1;  (*t)(2,5)  = 0.2;
      (*t)(0,6)  = 0.50;  (*t)(1,6)  =-0.05;  (*t)(2,6)  = 0.2;
      (*t)(0,7)  = 0.55;  (*t)(1,7)  = -0.1;  (*t)(2,7)  = 0.1;
      (*t)(0,8)  = 0.60;  (*t)(1,8)  =-0.05;  (*t)(2,8)  = 0.1;
      (*t)(0,9)  = 0.65;  (*t)(1,9)  =    0;  (*t)(2,9)  = 0.15;
      (*t)(0,10)  = 0.70;  (*t)(1,10)  = 0.05;  (*t)(2,10)  = 0.2;
      (*t)(0,11)  = 0.75;  (*t)(1,11)  =    0;  (*t)(2,11)  = 0;
    }
    else
    if (fParticleID==AliPID::kProton)
    {
      t = new TMatrixF(3,9);
      (*t)(0,0)  = 0.20;  (*t)(1,0)  = -0.1;  (*t)(2,0)  =  0.1; 
      (*t)(0,1)  = 0.25;  (*t)(1,1)  = -0.2;  (*t)(2,1)  =  0.2; 
      (*t)(0,2)  = 0.80;  (*t)(1,2)  = -0.1;  (*t)(2,2)  =  0.2; 
      (*t)(0,3)  = 0.85;  (*t)(1,3)  =-0.05;  (*t)(2,3)  =  0.2; 
      (*t)(0,4)  = 0.90;  (*t)(1,4)  =-0.05;  (*t)(2,4)  = 0.25; 
      (*t)(0,5)  = 0.95;  (*t)(1,5)  =-0.05;  (*t)(2,5)  = 0.25; 
      (*t)(0,6)  = 1.00;  (*t)(1,6)  = -0.1;  (*t)(2,6)  = 0.25; 
      (*t)(0,7)  = 1.10;  (*t)(1,7)  =-0.05;  (*t)(2,7)  =  0.3; 
      (*t)(0,8) = 1.20;   (*t)(1,8)  =    0;  (*t)(2,8) =    0;
    }
    delete fTPCpidCuts;
    fTPCpidCuts=t;
  }
  t = NULL;
  if (!fTOFpidCuts)
  {
    if (fParticleID==AliPID::kPion)
    {
      //TOF pions, 0.9 purity
      t = new TMatrixF(3,61);
      (*t)(0,0)  = 0.000;  (*t)(1,0)  = 0.000;  (*t)(2,0)  =   0.000;
      (*t)(0,1)  = 0.050;  (*t)(1,1)  = 0.000;  (*t)(2,1)  =   0.000;
      (*t)(0,2)  = 0.100;  (*t)(1,2)  = 0.000;  (*t)(2,2)  =   0.000;
      (*t)(0,3)  = 0.150;  (*t)(1,3)  = 0.000;  (*t)(2,3)  =   0.000;
      (*t)(0,4)  = 0.200;  (*t)(1,4)  = -0.030;  (*t)(2,4)  =   0.030;
      (*t)(0,5)  = 0.250;  (*t)(1,5)  = -0.036;  (*t)(2,5)  =   0.032;
      (*t)(0,6)  = 0.300;  (*t)(1,6)  = -0.038;  (*t)(2,6)  =   0.032;
      (*t)(0,7)  = 0.350;  (*t)(1,7)  = -0.034;  (*t)(2,7)  =   0.032;
      (*t)(0,8)  = 0.400;  (*t)(1,8)  = -0.032;  (*t)(2,8)  =   0.020;
      (*t)(0,9)  = 0.450;  (*t)(1,9)  = -0.030;  (*t)(2,9)  =   0.020;
      (*t)(0,10)  = 0.500;  (*t)(1,10)  = -0.030;  (*t)(2,10)  =   0.020;
      (*t)(0,11)  = 0.550;  (*t)(1,11)  = -0.030;  (*t)(2,11)  =   0.020;
      (*t)(0,12)  = 0.600;  (*t)(1,12)  = -0.030;  (*t)(2,12)  =   0.020;
      (*t)(0,13)  = 0.650;  (*t)(1,13)  = -0.030;  (*t)(2,13)  =   0.020;
      (*t)(0,14)  = 0.700;  (*t)(1,14)  = -0.030;  (*t)(2,14)  =   0.020;
      (*t)(0,15)  = 0.750;  (*t)(1,15)  = -0.030;  (*t)(2,15)  =   0.020;
      (*t)(0,16)  = 0.800;  (*t)(1,16)  = -0.030;  (*t)(2,16)  =   0.020;
      (*t)(0,17)  = 0.850;  (*t)(1,17)  = -0.030;  (*t)(2,17)  =   0.020;
      (*t)(0,18)  = 0.900;  (*t)(1,18)  = -0.030;  (*t)(2,18)  =   0.020;
      (*t)(0,19)  = 0.950;  (*t)(1,19)  = -0.028;  (*t)(2,19)  =   0.028;
      (*t)(0,20)  = 1.000;  (*t)(1,20)  = -0.028;  (*t)(2,20)  =   0.028;
      (*t)(0,21)  = 1.100;  (*t)(1,21)  = -0.028;  (*t)(2,21)  =   0.028;
      (*t)(0,22)  = 1.200;  (*t)(1,22)  = -0.026;  (*t)(2,22)  =   0.028;
      (*t)(0,23)  = 1.300;  (*t)(1,23)  = -0.024;  (*t)(2,23)  =   0.028;
      (*t)(0,24)  = 1.400;  (*t)(1,24)  = -0.020;  (*t)(2,24)  =   0.028;
      (*t)(0,25)  = 1.500;  (*t)(1,25)  = -0.018;  (*t)(2,25)  =   0.028;
      (*t)(0,26)  = 1.600;  (*t)(1,26)  = -0.016;  (*t)(2,26)  =   0.028;
      (*t)(0,27)  = 1.700;  (*t)(1,27)  = -0.014;  (*t)(2,27)  =   0.028;
      (*t)(0,28)  = 1.800;  (*t)(1,28)  = -0.012;  (*t)(2,28)  =   0.026;
      (*t)(0,29)  = 1.900;  (*t)(1,29)  = -0.010;  (*t)(2,29)  =   0.026;
      (*t)(0,30)  = 2.000;  (*t)(1,30)  = -0.008;  (*t)(2,30)  =   0.026;
      (*t)(0,31)  = 2.100;  (*t)(1,31)  = -0.008;  (*t)(2,31)  =   0.024;
      (*t)(0,32)  = 2.200;  (*t)(1,32)  = -0.006;  (*t)(2,32)  =   0.024;
      (*t)(0,33)  = 2.300;  (*t)(1,33)  = -0.004;  (*t)(2,33)  =   0.024;
      (*t)(0,34)  = 2.400;  (*t)(1,34)  = -0.004;  (*t)(2,34)  =   0.024;
      (*t)(0,35)  = 2.500;  (*t)(1,35)  = -0.002;  (*t)(2,35)  =   0.024;
      (*t)(0,36)  = 2.600;  (*t)(1,36)  = -0.002;  (*t)(2,36)  =   0.024;
      (*t)(0,37)  = 2.700;  (*t)(1,37)  = 0.000;  (*t)(2,37)  =   0.024;
      (*t)(0,38)  = 2.800;  (*t)(1,38)  = 0.000;  (*t)(2,38)  =   0.026;
      (*t)(0,39)  = 2.900;  (*t)(1,39)  = 0.000;  (*t)(2,39)  =   0.024;
      (*t)(0,40)  = 3.000;  (*t)(1,40)  = 0.002;  (*t)(2,40)  =   0.026;
      (*t)(0,41)  = 3.100;  (*t)(1,41)  = 0.002;  (*t)(2,41)  =   0.026;
      (*t)(0,42)  = 3.200;  (*t)(1,42)  = 0.002;  (*t)(2,42)  =   0.026;
      (*t)(0,43)  = 3.300;  (*t)(1,43)  = 0.002;  (*t)(2,43)  =   0.026;
      (*t)(0,44)  = 3.400;  (*t)(1,44)  = 0.002;  (*t)(2,44)  =   0.026;
      (*t)(0,45)  = 3.500;  (*t)(1,45)  = 0.002;  (*t)(2,45)  =   0.026;
      (*t)(0,46)  = 3.600;  (*t)(1,46)  = 0.002;  (*t)(2,46)  =   0.026;
      (*t)(0,47)  = 3.700;  (*t)(1,47)  = 0.002;  (*t)(2,47)  =   0.026;
      (*t)(0,48)  = 3.800;  (*t)(1,48)  = 0.002;  (*t)(2,48)  =   0.026;
      (*t)(0,49)  = 3.900;  (*t)(1,49)  = 0.004;  (*t)(2,49)  =   0.024;
      (*t)(0,50)  = 4.000;  (*t)(1,50)  = 0.004;  (*t)(2,50)  =   0.026;
      (*t)(0,51)  = 4.100;  (*t)(1,51)  = 0.004;  (*t)(2,51)  =   0.026;
      (*t)(0,52)  = 4.200;  (*t)(1,52)  = 0.004;  (*t)(2,52)  =   0.024;
      (*t)(0,53)  = 4.300;  (*t)(1,53)  = 0.006;  (*t)(2,53)  =   0.024;
      (*t)(0,54)  = 4.400;  (*t)(1,54)  = 0.000;  (*t)(2,54)  =   0.000;
      (*t)(0,55)  = 4.500;  (*t)(1,55)  = 0.000;  (*t)(2,55)  =   0.000;
      (*t)(0,56)  = 4.600;  (*t)(1,56)  = 0.000;  (*t)(2,56)  =   0.000;
      (*t)(0,57)  = 4.700;  (*t)(1,57)  = 0.000;  (*t)(2,57)  =   0.000;
      (*t)(0,58)  = 4.800;  (*t)(1,58)  = 0.000;  (*t)(2,58)  =   0.000;
      (*t)(0,59)  = 4.900;  (*t)(1,59)  = 0.000;  (*t)(2,59)  =   0.000;
      (*t)(0,60)  = 5.900;  (*t)(1,60)  = 0.000;  (*t)(2,60)  =   0.000;
    }
    else
    if (fParticleID==AliPID::kProton)
    {
      //TOF protons, 0.9 purity
      t = new TMatrixF(3,61);
      (*t)(0,0)  = 0.000;  (*t)(1,0)  = 0.000;  (*t)(2,0)  =   0.000;
      (*t)(0,1)  = 0.050;  (*t)(1,1)  = 0.000;  (*t)(2,1)  =   0.000;
      (*t)(0,2)  = 0.100;  (*t)(1,2)  = 0.000;  (*t)(2,2)  =   0.000;
      (*t)(0,3)  = 0.150;  (*t)(1,3)  = 0.000;  (*t)(2,3)  =   0.000;
      (*t)(0,4)  = 0.200;  (*t)(1,4)  = -0.07;  (*t)(2,4)  =   0.07;
      (*t)(0,5)  = 0.200;  (*t)(1,5)  = -0.07;  (*t)(2,5)  =   0.07;
      (*t)(0,6)  = 0.200;  (*t)(1,6)  = -0.07;  (*t)(2,6)  =   0.07;
      (*t)(0,7)  = 0.200;  (*t)(1,7)  = -0.07;  (*t)(2,7)  =   0.07;
      (*t)(0,8)  = 0.200;  (*t)(1,8)  = -0.07;  (*t)(2,8)  =   0.07;
      (*t)(0,9)  = 0.200;  (*t)(1,9)  = -0.07;  (*t)(2,9)  =   0.07;
      (*t)(0,10)  = 0.200;  (*t)(1,10)  = -0.07;  (*t)(2,10)  =   0.07;
      (*t)(0,11)  = 0.200;  (*t)(1,11)  = -0.07;  (*t)(2,11)  =   0.07;
      (*t)(0,12)  = 0.200;  (*t)(1,12)  = -0.07;  (*t)(2,12)  =   0.07;
      (*t)(0,13)  = 0.200;  (*t)(1,13)  = -0.07;  (*t)(2,13)  =   0.07;
      (*t)(0,14)  = 0.200;  (*t)(1,14)  = -0.07;  (*t)(2,14)  =   0.07;
      (*t)(0,15)  = 0.200;  (*t)(1,15)  = -0.07;  (*t)(2,15)  =   0.07;
      (*t)(0,16)  = 0.200;  (*t)(1,16)  = -0.07;  (*t)(2,16)  =   0.07;
      (*t)(0,17)  = 0.850;  (*t)(1,17)  = -0.070;  (*t)(2,17)  =   0.070;
      (*t)(0,18)  = 0.900;  (*t)(1,18)  = -0.072;  (*t)(2,18)  =   0.072;
      (*t)(0,19)  = 0.950;  (*t)(1,19)  = -0.072;  (*t)(2,19)  =   0.072;
      (*t)(0,20)  = 1.000;  (*t)(1,20)  = -0.074;  (*t)(2,20)  =   0.074;
      (*t)(0,21)  = 1.100;  (*t)(1,21)  = -0.032;  (*t)(2,21)  =   0.032;
      (*t)(0,22)  = 1.200;  (*t)(1,22)  = -0.026;  (*t)(2,22)  =   0.026;
      (*t)(0,23)  = 1.300;  (*t)(1,23)  = -0.026;  (*t)(2,23)  =   0.026;
      (*t)(0,24)  = 1.400;  (*t)(1,24)  = -0.024;  (*t)(2,24)  =   0.024;
      (*t)(0,25)  = 1.500;  (*t)(1,25)  = -0.024;  (*t)(2,25)  =   0.024;
      (*t)(0,26)  = 1.600;  (*t)(1,26)  = -0.026;  (*t)(2,26)  =   0.026;
      (*t)(0,27)  = 1.700;  (*t)(1,27)  = -0.026;  (*t)(2,27)  =   0.026;
      (*t)(0,28)  = 1.800;  (*t)(1,28)  = -0.026;  (*t)(2,28)  =   0.026;
      (*t)(0,29)  = 1.900;  (*t)(1,29)  = -0.026;  (*t)(2,29)  =   0.026;
      (*t)(0,30)  = 2.000;  (*t)(1,30)  = -0.026;  (*t)(2,30)  =   0.026;
      (*t)(0,31)  = 2.100;  (*t)(1,31)  = -0.026;  (*t)(2,31)  =   0.026;
      (*t)(0,32)  = 2.200;  (*t)(1,32)  = -0.026;  (*t)(2,32)  =   0.024;
      (*t)(0,33)  = 2.300;  (*t)(1,33)  = -0.028;  (*t)(2,33)  =   0.022;
      (*t)(0,34)  = 2.400;  (*t)(1,34)  = -0.028;  (*t)(2,34)  =   0.020;
      (*t)(0,35)  = 2.500;  (*t)(1,35)  = -0.028;  (*t)(2,35)  =   0.018;
      (*t)(0,36)  = 2.600;  (*t)(1,36)  = -0.028;  (*t)(2,36)  =   0.016;
      (*t)(0,37)  = 2.700;  (*t)(1,37)  = -0.028;  (*t)(2,37)  =   0.016;
      (*t)(0,38)  = 2.800;  (*t)(1,38)  = -0.030;  (*t)(2,38)  =   0.014;
      (*t)(0,39)  = 2.900;  (*t)(1,39)  = -0.030;  (*t)(2,39)  =   0.012;
      (*t)(0,40)  = 3.000;  (*t)(1,40)  = -0.030;  (*t)(2,40)  =   0.012;
      (*t)(0,41)  = 3.100;  (*t)(1,41)  = -0.030;  (*t)(2,41)  =   0.010;
      (*t)(0,42)  = 3.200;  (*t)(1,42)  = -0.030;  (*t)(2,42)  =   0.010;
      (*t)(0,43)  = 3.300;  (*t)(1,43)  = -0.030;  (*t)(2,43)  =   0.010;
      (*t)(0,44)  = 3.400;  (*t)(1,44)  = -0.030;  (*t)(2,44)  =   0.008;
      (*t)(0,45)  = 3.500;  (*t)(1,45)  = -0.030;  (*t)(2,45)  =   0.008;
      (*t)(0,46)  = 3.600;  (*t)(1,46)  = -0.030;  (*t)(2,46)  =   0.008;
      (*t)(0,47)  = 3.700;  (*t)(1,47)  = -0.030;  (*t)(2,47)  =   0.006;
      (*t)(0,48)  = 3.800;  (*t)(1,48)  = -0.030;  (*t)(2,48)  =   0.006;
      (*t)(0,49)  = 3.900;  (*t)(1,49)  = -0.030;  (*t)(2,49)  =   0.006;
      (*t)(0,50)  = 4.000;  (*t)(1,50)  = -0.028;  (*t)(2,50)  =   0.004;
      (*t)(0,51)  = 4.100;  (*t)(1,51)  = -0.030;  (*t)(2,51)  =   0.004;
      (*t)(0,52)  = 4.200;  (*t)(1,52)  = -0.030;  (*t)(2,52)  =   0.004;
      (*t)(0,53)  = 4.300;  (*t)(1,53)  = -0.028;  (*t)(2,53)  =   0.002;
      (*t)(0,54)  = 4.400;  (*t)(1,54)  = -0.030;  (*t)(2,54)  =   0.002;
      (*t)(0,55)  = 4.500;  (*t)(1,55)  = -0.028;  (*t)(2,55)  =   0.002;
      (*t)(0,56)  = 4.600;  (*t)(1,56)  = -0.028;  (*t)(2,56)  =   0.002;
      (*t)(0,57)  = 4.700;  (*t)(1,57)  = -0.028;  (*t)(2,57)  =   0.000;
      (*t)(0,58)  = 4.800;  (*t)(1,58)  = -0.028;  (*t)(2,58)  =   0.002;
      (*t)(0,59)  = 4.900;  (*t)(1,59)  = 0.000;  (*t)(2,59)  =   0.000;
      (*t)(0,60)  = 5.900;  (*t)(1,60)  = 0.000;  (*t)(2,60)  =   0.000; 
    }
    else
    if (fParticleID==AliPID::kKaon)
    {
      //TOF kaons, 0.9 purity
      t = new TMatrixF(3,61);
      (*t)(0,0)  = 0.000;  (*t)(1,0)  = 0.000;  (*t)(2,0)  =   0.000;
      (*t)(0,1)  = 0.050;  (*t)(1,1)  = 0.000;  (*t)(2,1)  =   0.000;
      (*t)(0,2)  = 0.100;  (*t)(1,2)  = 0.000;  (*t)(2,2)  =   0.000;
      (*t)(0,3)  = 0.150;  (*t)(1,3)  = 0.000;  (*t)(2,3)  =   0.000;
      (*t)(0,4)  = 0.200;  (*t)(1,4)  = -0.05;  (*t)(2,4)  =   0.05;
      (*t)(0,5)  = 0.200;  (*t)(1,5)  = -0.05;  (*t)(2,5)  =   0.05;
      (*t)(0,6)  = 0.200;  (*t)(1,6)  = -0.05;  (*t)(2,6)  =   0.05;
      (*t)(0,7)  = 0.200;  (*t)(1,7)  = -0.05;  (*t)(2,7)  =   0.05;
      (*t)(0,8)  = 0.200;  (*t)(1,8)  = -0.05;  (*t)(2,8)  =   0.05;
      (*t)(0,9)  = 0.200;  (*t)(1,9)  = -0.05;  (*t)(2,9)  =   0.05;
      (*t)(0,10)  = 0.200;  (*t)(1,10)  = -0.05;  (*t)(2,10)  =   0.05;
      (*t)(0,11)  = 0.550;  (*t)(1,11)  = -0.026;  (*t)(2,11)  =   0.026;
      (*t)(0,12)  = 0.600;  (*t)(1,12)  = -0.026;  (*t)(2,12)  =   0.026;
      (*t)(0,13)  = 0.650;  (*t)(1,13)  = -0.026;  (*t)(2,13)  =   0.026;
      (*t)(0,14)  = 0.700;  (*t)(1,14)  = -0.026;  (*t)(2,14)  =   0.026;
      (*t)(0,15)  = 0.750;  (*t)(1,15)  = -0.026;  (*t)(2,15)  =   0.026;
      (*t)(0,16)  = 0.800;  (*t)(1,16)  = -0.026;  (*t)(2,16)  =   0.026;
      (*t)(0,17)  = 0.850;  (*t)(1,17)  = -0.024;  (*t)(2,17)  =   0.024;
      (*t)(0,18)  = 0.900;  (*t)(1,18)  = -0.024;  (*t)(2,18)  =   0.024;
      (*t)(0,19)  = 0.950;  (*t)(1,19)  = -0.024;  (*t)(2,19)  =   0.024;
      (*t)(0,20)  = 1.000;  (*t)(1,20)  = -0.024;  (*t)(2,20)  =   0.024;
      (*t)(0,21)  = 1.100;  (*t)(1,21)  = -0.024;  (*t)(2,21)  =   0.024;
      (*t)(0,22)  = 1.200;  (*t)(1,22)  = -0.024;  (*t)(2,22)  =   0.022;
      (*t)(0,23)  = 1.300;  (*t)(1,23)  = -0.024;  (*t)(2,23)  =   0.020;
      (*t)(0,24)  = 1.400;  (*t)(1,24)  = -0.026;  (*t)(2,24)  =   0.016;
      (*t)(0,25)  = 1.500;  (*t)(1,25)  = -0.028;  (*t)(2,25)  =   0.014;
      (*t)(0,26)  = 1.600;  (*t)(1,26)  = -0.028;  (*t)(2,26)  =   0.012;
      (*t)(0,27)  = 1.700;  (*t)(1,27)  = -0.028;  (*t)(2,27)  =   0.010;
      (*t)(0,28)  = 1.800;  (*t)(1,28)  = -0.028;  (*t)(2,28)  =   0.010;
      (*t)(0,29)  = 1.900;  (*t)(1,29)  = -0.028;  (*t)(2,29)  =   0.008;
      (*t)(0,30)  = 2.000;  (*t)(1,30)  = -0.028;  (*t)(2,30)  =   0.006;
      (*t)(0,31)  = 2.100;  (*t)(1,31)  = -0.026;  (*t)(2,31)  =   0.006;
      (*t)(0,32)  = 2.200;  (*t)(1,32)  = -0.024;  (*t)(2,32)  =   0.004;
      (*t)(0,33)  = 2.300;  (*t)(1,33)  = -0.020;  (*t)(2,33)  =   0.002;
      (*t)(0,34)  = 2.400;  (*t)(1,34)  = -0.020;  (*t)(2,34)  =   0.002;
      (*t)(0,35)  = 2.500;  (*t)(1,35)  = -0.018;  (*t)(2,35)  =   0.000;
      (*t)(0,36)  = 2.600;  (*t)(1,36)  = -0.016;  (*t)(2,36)  =   0.000;
      (*t)(0,37)  = 2.700;  (*t)(1,37)  = -0.014;  (*t)(2,37)  =   -0.002;
      (*t)(0,38)  = 2.800;  (*t)(1,38)  = -0.014;  (*t)(2,38)  =   -0.004;
      (*t)(0,39)  = 2.900;  (*t)(1,39)  = -0.012;  (*t)(2,39)  =   -0.004;
      (*t)(0,40)  = 3.000;  (*t)(1,40)  = -0.010;  (*t)(2,40)  =   -0.006;
      (*t)(0,41)  = 3.100;  (*t)(1,41)  = 0.000;  (*t)(2,41)  =   0.000;
      (*t)(0,42)  = 3.200;  (*t)(1,42)  = 0.000;  (*t)(2,42)  =   0.000;
      (*t)(0,43)  = 3.300;  (*t)(1,43)  = 0.000;  (*t)(2,43)  =   0.000;
      (*t)(0,44)  = 3.400;  (*t)(1,44)  = 0.000;  (*t)(2,44)  =   0.000;
      (*t)(0,45)  = 3.500;  (*t)(1,45)  = 0.000;  (*t)(2,45)  =   0.000;
      (*t)(0,46)  = 3.600;  (*t)(1,46)  = 0.000;  (*t)(2,46)  =   0.000;
      (*t)(0,47)  = 3.700;  (*t)(1,47)  = 0.000;  (*t)(2,47)  =   0.000;
      (*t)(0,48)  = 3.800;  (*t)(1,48)  = 0.000;  (*t)(2,48)  =   0.000;
      (*t)(0,49)  = 3.900;  (*t)(1,49)  = 0.000;  (*t)(2,49)  =   0.000;
      (*t)(0,50)  = 4.000;  (*t)(1,50)  = 0.000;  (*t)(2,50)  =   0.000;
      (*t)(0,51)  = 4.100;  (*t)(1,51)  = 0.000;  (*t)(2,51)  =   0.000;
      (*t)(0,52)  = 4.200;  (*t)(1,52)  = 0.000;  (*t)(2,52)  =   0.000;
      (*t)(0,53)  = 4.300;  (*t)(1,53)  = 0.000;  (*t)(2,53)  =   0.000;
      (*t)(0,54)  = 4.400;  (*t)(1,54)  = 0.000;  (*t)(2,54)  =   0.000;
      (*t)(0,55)  = 4.500;  (*t)(1,55)  = 0.000;  (*t)(2,55)  =   0.000;
      (*t)(0,56)  = 4.600;  (*t)(1,56)  = 0.000;  (*t)(2,56)  =   0.000;
      (*t)(0,57)  = 4.700;  (*t)(1,57)  = 0.000;  (*t)(2,57)  =   0.000;
      (*t)(0,58)  = 4.800;  (*t)(1,58)  = 0.000;  (*t)(2,58)  =   0.000;
      (*t)(0,59)  = 4.900;  (*t)(1,59)  = 0.000;  (*t)(2,59)  =   0.000;
      (*t)(0,60)  = 5.900;  (*t)(1,60)  = 0.000;  (*t)(2,60)  =   0.000;
    }
    delete fTOFpidCuts;
    fTOFpidCuts=t;
  }
}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTPCbayesianCut(const AliAODTrack* track)
{
  fBayesianResponse->ComputeProb(track,track->GetAODEvent()); // fCurrCentr is needed for mismatch fraction
  Float_t *probabilities = fBayesianResponse->GetProb(); // Bayesian Probability (from 0 to 4) (Combined TPC || TOF) including a tuning of priors and TOF mism$

  Int_t kTPC = fBayesianResponse->GetCurrentMask(0); // is TPC on

  if(! kTPC) return kFALSE;

  fProbBayes = 0.0;

switch (fParticleID)
  {
    case AliPID::kPion:
      fProbBayes = probabilities[2];
      break;
    case AliPID::kKaon:
       fProbBayes = probabilities[3];
     break;
    case AliPID::kProton:
       fProbBayes = probabilities[4];
      break;
    case AliPID::kElectron:
       fProbBayes = probabilities[0];
     break;
    case AliPID::kMuon:
       fProbBayes = probabilities[1];
     break;
    case AliPID::kDeuteron:
       fProbBayes = probabilities[5];
     break;
    case AliPID::kTriton:
       fProbBayes = probabilities[6];
     break;
    case AliPID::kHe3:
       fProbBayes = probabilities[7];
     break;
   default:
      return kFALSE;
  }

 if(fProbBayes > fParticleProbability){
    if(!fCutCharge)
      return kTRUE;
    else if (fCutCharge && fCharge * track->Charge() > 0)
      return kTRUE;
  }
  return kFALSE;
}
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTPCbayesianCut(const AliESDtrack* track)
{
  //cut on TPC bayesian pid
  //if (! fAllowTOFmismatchFlag) {if (track->GetStatus() & AliESDtrack::kTOFmismatch) return kFALSE;}

  //Bool_t statusMatchingHard = TPCTOFagree(track);
  //if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
  //     return kFALSE;
  fBayesianResponse->ComputeProb(track,fCurrCentr); // fCurrCentr is needed for mismatch fraction
  Int_t kTPC = fBayesianResponse->GetCurrentMask(0); // is TPC on
  //Int_t kTOF = fBayesianResponse->GetCurrentMask(1); // is TOF on

  if(! kTPC) return kFALSE;

  //  Bool_t statusMatchingHard = 1;
  //  Float_t mismProb = 0;
  //  if(kTOF){
  //    statusMatchingHard = TPCTOFagree(track);
  //    mismProb = fBayesianResponse->GetTOFMismProb();
  //  }
  //  if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
  //       return kFALSE;

  Float_t *probabilities = fBayesianResponse->GetProb(); // Bayesian Probability (from 0 to 4) (Combined TPC || TOF) including a tuning of priors and TOF mismatch parameterization

  fProbBayes = 0.0;

  switch (fParticleID)
  {
    case AliPID::kPion:
      fProbBayes = probabilities[2];
      break;
    case AliPID::kKaon:
      fProbBayes = probabilities[3];
     break;
    case AliPID::kProton:
      fProbBayes = probabilities[4];
      break;
    case AliPID::kElectron:
       fProbBayes = probabilities[0];
     break;
    case AliPID::kMuon:
       fProbBayes = probabilities[1];
     break;
    case AliPID::kDeuteron:
       fProbBayes = probabilities[5];
     break;
    case AliPID::kTriton:
       fProbBayes = probabilities[6];
     break;
    case AliPID::kHe3:
       fProbBayes = probabilities[7];
     break;
    default:
      return kFALSE;
  }

  if(fProbBayes > fParticleProbability)
    {
      if(!fCutCharge)
	return kTRUE;
      else if (fCutCharge && fCharge * track->GetSign() > 0)
	return kTRUE;
    }
  return kFALSE;
}
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTOFbayesianCut(const AliAODTrack* track)
{  
  //check is track passes bayesian combined TOF+TPC pid cut
  Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFout) &&
                     (track->GetStatus() & AliESDtrack::kTIME) &&
                     (track->GetTOFsignal() > 12000) &&
                     (track->GetTOFsignal() < 100000);

  if (! goodtrack)   
       return kFALSE;

  Bool_t statusMatchingHard = TPCTOFagree(track);
  if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
       return kFALSE;

 fBayesianResponse->ComputeProb(track,track->GetAODEvent()); // fCurrCentr is needed for mismatch fraction
  Float_t *probabilities = fBayesianResponse->GetProb(); // Bayesian Probability (from 0 to 4) (Combined TPC || TOF) including a tuning of priors and TOF mism$

  Float_t mismProb = fBayesianResponse->GetTOFMismProb(); // mismatch Bayesian probabilities

  fProbBayes = 0.0;

 switch (fParticleID)
  {
    case AliPID::kPion:
      fProbBayes = probabilities[2];
      break;
    case AliPID::kKaon:
       fProbBayes = probabilities[3];
     break;
    case AliPID::kProton:
       fProbBayes = probabilities[4];
      break;
    case AliPID::kElectron:
       fProbBayes = probabilities[0];
     break;
    case AliPID::kMuon:
       fProbBayes = probabilities[1];
     break;
    case AliPID::kDeuteron:
       fProbBayes = probabilities[5];
     break;
    case AliPID::kTriton:
       fProbBayes = probabilities[6];
     break;
    case AliPID::kHe3:
       fProbBayes = probabilities[7];
     break;
   default:
      return kFALSE;
  }

 if(fProbBayes > fParticleProbability && mismProb < 0.5){
    if(!fCutCharge)
      return kTRUE;
    else if (fCutCharge && fCharge * track->Charge() > 0)
      return kTRUE;
  }
  return kFALSE;

}
//-----------------------------------------------------------------------
// part added by F. Noferini (some methods)
Bool_t AliFlowTrackCuts::PassesTOFbayesianCut(const AliESDtrack* track)
{
  //check is track passes bayesian combined TOF+TPC pid cut
  Bool_t goodtrack = (track->GetStatus() & AliESDtrack::kTOFout) && 
                     (track->GetStatus() & AliESDtrack::kTIME) &&
                     (track->GetTOFsignal() > 12000) && 
                     (track->GetTOFsignal() < 100000) && 
                     (track->GetIntegratedLength() > 365);

  if (! goodtrack)
       return kFALSE;

  if (! fAllowTOFmismatchFlag) {if (track->GetStatus() & AliESDtrack::kTOFmismatch) return kFALSE;}

  Bool_t statusMatchingHard = TPCTOFagree(track);
  if (fRequireStrictTOFTPCagreement && (!statusMatchingHard))
       return kFALSE;

  fBayesianResponse->ComputeProb(track,fCurrCentr); // fCurrCentr is needed for mismatch fraction
  Float_t *probabilities = fBayesianResponse->GetProb(); // Bayesian Probability (from 0 to 4) (Combined TPC || TOF) including a tuning of priors and TOF mismatch parameterization

  Float_t mismProb = fBayesianResponse->GetTOFMismProb(); // mismatch Bayesian probabilities

  fProbBayes = 0.0;

  switch (fParticleID)
  {
    case AliPID::kPion:
      fProbBayes = probabilities[2];
      break;
    case AliPID::kKaon:
       fProbBayes = probabilities[3];
     break;
    case AliPID::kProton:
       fProbBayes = probabilities[4];
      break;
    case AliPID::kElectron:
       fProbBayes = probabilities[0];
     break;
    case AliPID::kMuon:
       fProbBayes = probabilities[1];
     break;
    case AliPID::kDeuteron:
       fProbBayes = probabilities[5];
     break;
    case AliPID::kTriton:
       fProbBayes = probabilities[6];
     break;
    case AliPID::kHe3:
       fProbBayes = probabilities[7];
     break;
   default:
      return kFALSE;
  }

  //  printf("pt = %f -- all prob = [%4.2f,%4.2f,%4.2f,%4.2f,%4.2f] -- prob = %f\n",track->Pt(),fProbBayes[0],fProbBayes[1],fProbBayes[2],fProbBayes[3],fProbBayes[4],prob);
  if(fProbBayes > fParticleProbability && mismProb < 0.5){
    if(!fCutCharge)
      return kTRUE;
    else if (fCutCharge && fCharge * track->GetSign() > 0)
      return kTRUE;
  }
  return kFALSE;
}


//-----------------------------------------------------------------------
 // part added by Natasha
Bool_t AliFlowTrackCuts::PassesNucleiSelection(const AliESDtrack* track)
{
  //pid selection for heavy nuclei
  Bool_t select=kFALSE;

  //if (!track) continue; 

  if (!track->GetInnerParam()) 
    return kFALSE;    //break;

  const AliExternalTrackParam* tpcTrack = track->GetInnerParam();

  Double_t ptotTPC = tpcTrack->GetP();
  Double_t sigTPC = track->GetTPCsignal();
  Double_t dEdxBBA = 0.;
  Double_t dSigma = 0.; 

  switch (fParticleID)
  {
    case AliPID::kDeuteron:
      //pid=10;
      dEdxBBA = AliExternalTrackParam::BetheBlochAleph(ptotTPC/1.8756,
          4.60e+00,
          8.9684e+00,
          1.640e-05,
          2.35e+00,
          2.35e+00);
      dSigma = (sigTPC -  dEdxBBA)/dEdxBBA;

      if( ptotTPC<=1.1 && (dSigma < (0.5 - (0.1818*ptotTPC)) ) && (dSigma > ( (0.218*ptotTPC - 0.4) ) )  )
      {select=kTRUE;}
      break;

    case AliPID::kTriton:
      //pid=11;
      select=kFALSE;
      break;

    case AliPID::kHe3:
      //pid=12;
      // ----- Pass 2 -------
      dEdxBBA = 4.0 * AliExternalTrackParam::BetheBlochAleph( (2.*ptotTPC)/2.8084,
          1.74962,
          27.4992,
          4.00313e-15,
          2.42485,
          8.31768);
      dSigma = (sigTPC -  dEdxBBA)/dEdxBBA;
      if(ptotTPC<=5.0 && (dSigma >= (-0.03968*ptotTPC - 0.1)) && (dSigma <= (0.31 - 0.0217*ptotTPC)))
      {select=kTRUE;}
      break;

    case AliPID::kAlpha:
      //pid=13;
      select=kFALSE;
      break;

    default:
      return kFALSE;
  }       

  return select;
}
// end part added by Natasha
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTPCTOFNsigmaCut(const AliAODTrack* track) 
{
    // do a simple combined cut on the n sigma from tpc and tof
    // with information of the pid response object (needs pid response task)
    // stub, not implemented yet
    if(!fPIDResponse) return kFALSE;
    if(!track) return kFALSE;

    // check TOF status
    if ((track->GetStatus()&AliVTrack::kTOFout)==0) return kFALSE;
    if ((track->GetStatus()&AliVTrack::kTIME)==0) return kFALSE;

    // check TPC status
    if(track->GetTPCsignal() < 10) return kFALSE;

    Float_t nsigmaTPC = fPIDResponse->NumberOfSigmas(AliPIDResponse::kTPC,track,fParticleID);
    Float_t nsigmaTOF = fPIDResponse->NumberOfSigmas(AliPIDResponse::kTOF,track,fParticleID);

    Float_t nsigma2 = nsigmaTPC*nsigmaTPC + nsigmaTOF*nsigmaTOF;

    return (nsigma2 < fNsigmaCut2);

}
//-----------------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesTPCTOFNsigmaCut(const AliESDtrack* track)
{
    // do a simple combined cut on the n sigma from tpc and tof
    // with information of the pid response object (needs pid response task)
    // stub, not implemented yet
    if(!fPIDResponse) return kFALSE;
    if(!track) return kFALSE;

    // check TOF status
    if ((track->GetStatus()&AliVTrack::kTOFout)==0) return kFALSE;
    if ((track->GetStatus()&AliVTrack::kTIME)==0) return kFALSE;

    // check TPC status
    if(track->GetTPCsignal() < 10) return kFALSE;

    Float_t nsigmaTPC = fPIDResponse->NumberOfSigmas(AliPIDResponse::kTPC,track,fParticleID);
    Float_t nsigmaTOF = fPIDResponse->NumberOfSigmas(AliPIDResponse::kTOF,track,fParticleID);

    Float_t nsigma2 = nsigmaTPC*nsigmaTPC + nsigmaTOF*nsigmaTOF;

    return (nsigma2 < fNsigmaCut2);

}

//-----------------------------------------------------------------------
void AliFlowTrackCuts::SetPriors(Float_t centrCur){
 //set priors for the bayesian pid selection
  fCurrCentr = centrCur;

  fBinLimitPID[0] = 0.300000;
  fBinLimitPID[1] = 0.400000;
  fBinLimitPID[2] = 0.500000;
  fBinLimitPID[3] = 0.600000;
  fBinLimitPID[4] = 0.700000;
  fBinLimitPID[5] = 0.800000;
  fBinLimitPID[6] = 0.900000;
  fBinLimitPID[7] = 1.000000;
  fBinLimitPID[8] = 1.200000;
  fBinLimitPID[9] = 1.400000;
  fBinLimitPID[10] = 1.600000;
  fBinLimitPID[11] = 1.800000;
  fBinLimitPID[12] = 2.000000;
  fBinLimitPID[13] = 2.200000;
  fBinLimitPID[14] = 2.400000;
  fBinLimitPID[15] = 2.600000;
  fBinLimitPID[16] = 2.800000;
  fBinLimitPID[17] = 3.000000;
 
  // 0-10%
  if(centrCur < 10){
      fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0168;
      fC[1][4] = 0.0122;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0272;
      fC[2][4] = 0.0070;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0562;
      fC[3][4] = 0.0258;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0861;
      fC[4][4] = 0.0496;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1168;
      fC[5][4] = 0.0740;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1476;
      fC[6][4] = 0.0998;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1810;
      fC[7][4] = 0.1296;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.2240;
      fC[8][4] = 0.1827;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2812;
      fC[9][4] = 0.2699;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.3328;
      fC[10][4] = 0.3714;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.3780;
      fC[11][4] = 0.4810;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.4125;
      fC[12][4] = 0.5771;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.4486;
      fC[13][4] = 0.6799;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.4840;
      fC[14][4] = 0.7668;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.4971;
      fC[15][4] = 0.8288;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.4956;
      fC[16][4] = 0.8653;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.5173;
      fC[17][4] = 0.9059;   
  }
  // 10-20%
  else if(centrCur < 20){
     fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0132;
      fC[1][4] = 0.0088;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0283;
      fC[2][4] = 0.0068;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0577;
      fC[3][4] = 0.0279;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0884;
      fC[4][4] = 0.0534;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1179;
      fC[5][4] = 0.0794;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1480;
      fC[6][4] = 0.1058;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1807;
      fC[7][4] = 0.1366;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.2219;
      fC[8][4] = 0.1891;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2804;
      fC[9][4] = 0.2730;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.3283;
      fC[10][4] = 0.3660;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.3710;
      fC[11][4] = 0.4647;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.4093;
      fC[12][4] = 0.5566;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.4302;
      fC[13][4] = 0.6410;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.4649;
      fC[14][4] = 0.7055;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.4523;
      fC[15][4] = 0.7440;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.4591;
      fC[16][4] = 0.7799;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.4804;
      fC[17][4] = 0.8218;
  }
  // 20-30%
  else if(centrCur < 30){
     fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0102;
      fC[1][4] = 0.0064;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0292;
      fC[2][4] = 0.0066;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0597;
      fC[3][4] = 0.0296;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0900;
      fC[4][4] = 0.0589;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1199;
      fC[5][4] = 0.0859;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1505;
      fC[6][4] = 0.1141;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1805;
      fC[7][4] = 0.1454;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.2221;
      fC[8][4] = 0.2004;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2796;
      fC[9][4] = 0.2838;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.3271;
      fC[10][4] = 0.3682;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.3648;
      fC[11][4] = 0.4509;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.3988;
      fC[12][4] = 0.5339;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.4315;
      fC[13][4] = 0.5995;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.4548;
      fC[14][4] = 0.6612;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.4744;
      fC[15][4] = 0.7060;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.4899;
      fC[16][4] = 0.7388;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.4411;
      fC[17][4] = 0.7293;
  }
  // 30-40%
  else if(centrCur < 40){
      fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0102;
      fC[1][4] = 0.0048;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0306;
      fC[2][4] = 0.0079;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0617;
      fC[3][4] = 0.0338;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0920;
      fC[4][4] = 0.0652;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1211;
      fC[5][4] = 0.0955;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1496;
      fC[6][4] = 0.1242;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1807;
      fC[7][4] = 0.1576;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.2195;
      fC[8][4] = 0.2097;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2732;
      fC[9][4] = 0.2884;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.3204;
      fC[10][4] = 0.3679;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.3564;
      fC[11][4] = 0.4449;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.3791;
      fC[12][4] = 0.5052;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.4062;
      fC[13][4] = 0.5647;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.4234;
      fC[14][4] = 0.6203;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.4441;
      fC[15][4] = 0.6381;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.4629;
      fC[16][4] = 0.6496;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.4293;
      fC[17][4] = 0.6491;
  }
  // 40-50%
  else if(centrCur < 50){
      fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0093;
      fC[1][4] = 0.0057;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0319;
      fC[2][4] = 0.0075;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0639;
      fC[3][4] = 0.0371;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0939;
      fC[4][4] = 0.0725;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1224;
      fC[5][4] = 0.1045;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1520;
      fC[6][4] = 0.1387;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1783;
      fC[7][4] = 0.1711;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.2202;
      fC[8][4] = 0.2269;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2672;
      fC[9][4] = 0.2955;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.3191;
      fC[10][4] = 0.3676;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.3434;
      fC[11][4] = 0.4321;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.3692;
      fC[12][4] = 0.4879;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.3993;
      fC[13][4] = 0.5377;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.3818;
      fC[14][4] = 0.5547;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.4003;
      fC[15][4] = 0.5484;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.4281;
      fC[16][4] = 0.5383;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.3960;
      fC[17][4] = 0.5374;
  }
  // 50-60%
  else if(centrCur < 60){
      fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0076;
      fC[1][4] = 0.0032;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0329;
      fC[2][4] = 0.0085;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0653;
      fC[3][4] = 0.0423;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0923;
      fC[4][4] = 0.0813;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1219;
      fC[5][4] = 0.1161;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1519;
      fC[6][4] = 0.1520;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1763;
      fC[7][4] = 0.1858;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.2178;
      fC[8][4] = 0.2385;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2618;
      fC[9][4] = 0.3070;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.3067;
      fC[10][4] = 0.3625;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.3336;
      fC[11][4] = 0.4188;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.3706;
      fC[12][4] = 0.4511;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.3765;
      fC[13][4] = 0.4729;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.3942;
      fC[14][4] = 0.4855;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.4051;
      fC[15][4] = 0.4762;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.3843;
      fC[16][4] = 0.4763;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.4237;
      fC[17][4] = 0.4773;
  }
  // 60-70%
  else if(centrCur < 70){
         fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0071;
      fC[1][4] = 0.0012;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0336;
      fC[2][4] = 0.0097;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0662;
      fC[3][4] = 0.0460;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0954;
      fC[4][4] = 0.0902;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1181;
      fC[5][4] = 0.1306;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1481;
      fC[6][4] = 0.1662;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1765;
      fC[7][4] = 0.1963;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.2155;
      fC[8][4] = 0.2433;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2580;
      fC[9][4] = 0.3022;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.2872;
      fC[10][4] = 0.3481;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.3170;
      fC[11][4] = 0.3847;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.3454;
      fC[12][4] = 0.4258;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.3580;
      fC[13][4] = 0.4299;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.3903;
      fC[14][4] = 0.4326;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.3690;
      fC[15][4] = 0.4491;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.4716;
      fC[16][4] = 0.4298;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.3875;
      fC[17][4] = 0.4083;
  }
  // 70-80%
  else if(centrCur < 80){
      fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0075;
      fC[1][4] = 0.0007;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0313;
      fC[2][4] = 0.0124;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0640;
      fC[3][4] = 0.0539;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0923;
      fC[4][4] = 0.0992;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1202;
      fC[5][4] = 0.1417;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1413;
      fC[6][4] = 0.1729;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1705;
      fC[7][4] = 0.1999;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.2103;
      fC[8][4] = 0.2472;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2373;
      fC[9][4] = 0.2916;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.2824;
      fC[10][4] = 0.3323;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.3046;
      fC[11][4] = 0.3576;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.3585;
      fC[12][4] = 0.4003;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.3461;
      fC[13][4] = 0.3982;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.3362;
      fC[14][4] = 0.3776;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.3071;
      fC[15][4] = 0.3500;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.2914;
      fC[16][4] = 0.3937;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.3727;
      fC[17][4] = 0.3877;
  }
  // 80-100%
  else{
      fC[0][0] = 0.005;
      fC[0][1] = 0.005;
      fC[0][2] = 1.0000;
      fC[0][3] = 0.0010;
      fC[0][4] = 0.0010;

      fC[1][0] = 0.005;
      fC[1][1] = 0.005;
      fC[1][2] = 1.0000;
      fC[1][3] = 0.0060;
      fC[1][4] = 0.0035;

      fC[2][0] = 0.005;
      fC[2][1] = 0.005;
      fC[2][2] = 1.0000;
      fC[2][3] = 0.0323;
      fC[2][4] = 0.0113;

      fC[3][0] = 0.005;
      fC[3][1] = 0.005;
      fC[3][2] = 1.0000;
      fC[3][3] = 0.0609;
      fC[3][4] = 0.0653;

      fC[4][0] = 0.005;
      fC[4][1] = 0.005;
      fC[4][2] = 1.0000;
      fC[4][3] = 0.0922;
      fC[4][4] = 0.1076;

      fC[5][0] = 0.005;
      fC[5][1] = 0.005;
      fC[5][2] = 1.0000;
      fC[5][3] = 0.1096;
      fC[5][4] = 0.1328;

      fC[6][0] = 0.005;
      fC[6][1] = 0.005;
      fC[6][2] = 1.0000;
      fC[6][3] = 0.1495;
      fC[6][4] = 0.1779;

      fC[7][0] = 0.005;
      fC[7][1] = 0.005;
      fC[7][2] = 1.0000;
      fC[7][3] = 0.1519;
      fC[7][4] = 0.1989;

      fC[8][0] = 0.005;
      fC[8][1] = 0.005;
      fC[8][2] = 1.0000;
      fC[8][3] = 0.1817;
      fC[8][4] = 0.2472;

      fC[9][0] = 0.005;
      fC[9][1] = 0.005;
      fC[9][2] = 1.0000;
      fC[9][3] = 0.2429;
      fC[9][4] = 0.2684;

      fC[10][0] = 0.005;
      fC[10][1] = 0.005;
      fC[10][2] = 1.0000;
      fC[10][3] = 0.2760;
      fC[10][4] = 0.3098;

      fC[11][0] = 0.005;
      fC[11][1] = 0.005;
      fC[11][2] = 1.0000;
      fC[11][3] = 0.2673;
      fC[11][4] = 0.3198;

      fC[12][0] = 0.005;
      fC[12][1] = 0.005;
      fC[12][2] = 1.0000;
      fC[12][3] = 0.3165;
      fC[12][4] = 0.3564;

      fC[13][0] = 0.005;
      fC[13][1] = 0.005;
      fC[13][2] = 1.0000;
      fC[13][3] = 0.3526;
      fC[13][4] = 0.3011;

      fC[14][0] = 0.005;
      fC[14][1] = 0.005;
      fC[14][2] = 1.0000;
      fC[14][3] = 0.3788;
      fC[14][4] = 0.3011;

      fC[15][0] = 0.005;
      fC[15][1] = 0.005;
      fC[15][2] = 1.0000;
      fC[15][3] = 0.3788;
      fC[15][4] = 0.3011;

      fC[16][0] = 0.005;
      fC[16][1] = 0.005;
      fC[16][2] = 1.0000;
      fC[16][3] = 0.3788;
      fC[16][4] = 0.3011;

      fC[17][0] = 0.005;
      fC[17][1] = 0.005;
      fC[17][2] = 1.0000;
      fC[17][3] = 0.3788;
      fC[17][4] = 0.3011;
  }
  
  for(Int_t i=18;i<fgkPIDptBin;i++){
    fBinLimitPID[i] = 3.0 + 0.2 * (i-18);
    fC[i][0] = fC[17][0];
    fC[i][1] = fC[17][1];
    fC[i][2] = fC[17][2];
    fC[i][3] = fC[17][3];
    fC[i][4] = fC[17][4];
  }  
}

//---------------------------------------------------------------//
Bool_t AliFlowTrackCuts::TPCTOFagree(const AliVTrack *track)
{
  //check pid agreement between TPC and TOF
  Bool_t status = kFALSE;

  const Float_t c = 2.99792457999999984e-02;

  Float_t mass[5] = {5.10998909999999971e-04,1.05658000000000002e-01,1.39570000000000000e-01,4.93676999999999977e-01,9.38271999999999995e-01};
  

  Double_t exptimes[9];
  track->GetIntegratedTimes(exptimes);
  
  Float_t dedx = track->GetTPCsignal();

  Float_t p = track->P();
  Float_t time = track->GetTOFsignal()- fESDpid.GetTOFResponse().GetStartTime(p);
  Float_t tl = exptimes[0]*c; // to work both for ESD and AOD

  Float_t betagammares =  fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[4], mass[4]);

  Float_t betagamma1 = tl/(time-5 *betagammares) * 33.3564095198152043;

//  printf("betagamma1 = %f\n",betagamma1);

  if(betagamma1 < 0.1) betagamma1 = 0.1;

  if(betagamma1 < 0.99999) betagamma1 /= TMath::Sqrt(1-betagamma1*betagamma1);
  else betagamma1 = 100;

  Float_t betagamma2 = tl/(time+5 *betagammares) * 33.3564095198152043;
//  printf("betagamma2 = %f\n",betagamma2);

  if(betagamma2 < 0.1) betagamma2 = 0.1;

  if(betagamma2 < 0.99999) betagamma2 /= TMath::Sqrt(1-betagamma2*betagamma2);
  else betagamma2 = 100;


  Float_t momtpc=track->GetTPCmomentum();
 
  for(Int_t i=0;i < 5;i++){
    Float_t resolutionTOF =  fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[i], mass[i]);
    if(TMath::Abs(exptimes[i] - time) < 5 * resolutionTOF){
      Float_t dedxExp = 0;
      if(i==0) dedxExp =  fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kElectron);
      else if(i==1) dedxExp =  fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kMuon);
      else if(i==2) dedxExp =  fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kPion);
      else if(i==3) dedxExp =  fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kKaon);
      else if(i==4) dedxExp =  fESDpid.GetTPCResponse().GetExpectedSignal(momtpc,AliPID::kProton);

      Float_t resolutionTPC = 2;
      if(i==0) resolutionTPC =   fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kElectron); 
      else if(i==1) resolutionTPC =   fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kMuon);
      else if(i==2) resolutionTPC =   fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kPion);
      else if(i==3) resolutionTPC =   fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kKaon);
      else if(i==4) resolutionTPC =   fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kProton);

      if(TMath::Abs(dedx - dedxExp) < 3 * resolutionTPC){
	status = kTRUE;
      }
    }
  }

  Float_t bb1 =  fESDpid.GetTPCResponse().Bethe(betagamma1);
  Float_t bb2 =  fESDpid.GetTPCResponse().Bethe(betagamma2);
  Float_t bbM =  fESDpid.GetTPCResponse().Bethe((betagamma1+betagamma2)*0.5);


  //  status = kFALSE;
  // for nuclei
  Float_t resolutionTOFpr =   fESDpid.GetTOFResponse().GetExpectedSigma(p, exptimes[4], mass[4]);
  Float_t resolutionTPCpr =   fESDpid.GetTPCResponse().GetExpectedSigma(momtpc,track->GetTPCsignalN(),AliPID::kProton);
  if(TMath::Abs(dedx-bb1) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){
     status = kTRUE;
  }
  else if(TMath::Abs(dedx-bb2) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){
     status = kTRUE;
  }
  else if(TMath::Abs(dedx-bbM) < resolutionTPCpr*3 && exptimes[4] < time-7*resolutionTOFpr){
     status = kTRUE;
  }
  
  return status;
}
// end part added by F. Noferini
//-----------------------------------------------------------------------

//-----------------------------------------------------------------------
const char* AliFlowTrackCuts::PIDsourceName(PIDsource s)
{
  //get the name of the particle id source
  switch (s)
  {
    case kTPCdedx:
      return "TPCdedx";
    case kTPCbayesian:
      return "TPCbayesian";
    case kTOFbeta:
      return "TOFbeta";
    case kTPCpid:
      return "TPCpid";
    case kTOFpid:
      return "TOFpid";
    case kTOFbayesian:
      return "TOFbayesianPID";
    case kTOFbetaSimple:
      return "TOFbetaSimple";
    case kTPCNuclei:
      return "TPCnuclei";
    case kTPCTOFNsigma:
      return "TPCTOFNsigma";
    default:
      return "NOPID";
  }
}

//-----------------------------------------------------------------------
const char* AliFlowTrackCuts::GetParamTypeName(trackParameterType type) 
{
  //return the name of the selected parameter type
  switch (type)
  {
    case kMC:
      return "MC";
    case kGlobal:
      return "Global";
    case kTPCstandalone:
      return "TPCstandalone";
    case kSPDtracklet:
      return "SPDtracklets";
    case kPMD:
      return "PMD";
    case kVZERO:
      return "VZERO";
    case kMUON:       // XZhang 20120604
      return "MUON";  // XZhang 20120604
    case kKink:
      return "Kink";
    case kV0:
      return "V0";
    default:
      return "unknown";
  }
}

//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesPMDcuts(const AliESDPmdTrack* track )
{
  //check PMD specific cuts
  //clean up from last iteration, and init label
  Int_t   det   = track->GetDetector();
  //Int_t   smn   = track->GetSmn();
  Float_t clsX  = track->GetClusterX();
  Float_t clsY  = track->GetClusterY();
  Float_t clsZ  = track->GetClusterZ();
  Float_t ncell = track->GetClusterCells();
  Float_t adc   = track->GetClusterADC();

  fTrack = NULL;
  fMCparticle=NULL;
  fTrackLabel=-996;

  fTrackEta = GetPmdEta(clsX,clsY,clsZ);
  fTrackPhi = GetPmdPhi(clsX,clsY);
  fTrackWeight = 1.0;

  Bool_t pass=kTRUE;
  if (fCutEta) {if (  fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) pass = kFALSE;}
  if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) pass = kFALSE;}
  if (fCutPmdDet) {if(det != fPmdDet) pass = kFALSE;}
  if (fCutPmdAdc) {if(adc < fPmdAdc) pass = kFALSE;}
  if (fCutPmdNcell) {if(ncell < fPmdNcell) pass = kFALSE;}

  return pass;
}
  
//-----------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesVZEROcuts(Int_t id)
{
  //check VZERO cuts
  if (id<0) return kFALSE;

  //clean up from last iter
  ClearTrack();

  fTrackPhi = TMath::PiOver4()*(0.5+id%8);

  // 10102013 weighting vzero tiles - rbertens@cern.ch
  if(!fVZEROgainEqualization) {
      // if for some reason the equalization is not initialized (e.g. 2011 data)
      // the fVZEROxpol[] weights are used to enable or disable vzero rings
    if(id<32) {   // v0c side
      fTrackEta = -3.45+0.5*(id/8);
      if(id < 8) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROCpol[0];
      else if (id < 16 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROCpol[1];
      else if (id < 24 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROCpol[2];
      else if (id < 32 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROCpol[3];
    } else {       // v0a side
      fTrackEta = +4.8-0.6*((id/8)-4);
      if( id < 40) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROApol[0];
      else if ( id < 48 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROApol[1];
      else if ( id < 56 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROApol[2];
      else if ( id < 64 ) fTrackWeight = fEvent->GetVZEROEqMultiplicity(id)*fVZEROApol[3];
    }
  } else { // the equalization is initialized
     // note that disabled rings have already been excluded on calibration level in 
     // AliFlowEvent (so for a disabled ring, fVZEROxpol is zero
    if(id<32) {    // v0c side
      fTrackEta = -3.45+0.5*(id/8);
      if(id < 8) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROCpol[0]/fVZEROgainEqualization->GetBinContent(1+id);
      else if (id < 16 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROCpol[1]/fVZEROgainEqualization->GetBinContent(1+id);
      else if (id < 24 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROCpol[2]/fVZEROgainEqualization->GetBinContent(1+id);
      else if (id < 32 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROCpol[3]/fVZEROgainEqualization->GetBinContent(1+id);
    } else {       // v0a side
      fTrackEta = +4.8-0.6*((id/8)-4);
      if( id < 40) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROApol[0]/fVZEROgainEqualization->GetBinContent(1+id);
      else if ( id < 48 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROApol[1]/fVZEROgainEqualization->GetBinContent(1+id);
      else if ( id < 56 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROApol[2]/fVZEROgainEqualization->GetBinContent(1+id);
      else if ( id < 64 ) fTrackWeight = fEvent->GetVZEROData()->GetMultiplicity(id)*fVZEROApol[3]/fVZEROgainEqualization->GetBinContent(1+id);
    }
    // printf ( " tile %i and weight %.2f \n", id, fTrackWeight);
  }

  if (fLinearizeVZEROresponse && id < 64)
  {
    //this is only needed in pass1 of LHC10h
    Float_t multVZERO[fgkNumberOfVZEROtracks];
    Float_t dummy=0.0;
    AliESDUtils::GetCorrV0((AliESDEvent*)fEvent,dummy,multVZERO);
    fTrackWeight = multVZERO[id];
  }

  Bool_t pass=kTRUE;
  if (fCutEta) {if (  fTrackEta < fEtaMin || fTrackEta >= fEtaMax ) pass = kFALSE;}
  if (fCutPhi) {if ( fTrackPhi < fPhiMin || fTrackPhi >= fPhiMax ) pass = kFALSE;}

  return pass;
}

//-----------------------------------------------------------------------------
Bool_t AliFlowTrackCuts::PassesMuonCuts(AliVParticle* vparticle)
{
// XZhang 20120604
  ClearTrack();
  fTrackLabel = (fFakesAreOK)?TMath::Abs(vparticle->GetLabel()):vparticle->GetLabel();
  if (fMCevent) fMCparticle = static_cast<AliMCParticle*>(fMCevent->GetTrack(fTrackLabel));
  else fMCparticle=NULL;

  AliESDMuonTrack *esdTrack = dynamic_cast<AliESDMuonTrack*>(vparticle);
  AliAODTrack     *aodTrack = dynamic_cast<AliAODTrack*>(vparticle);
  if ((!esdTrack) && (!aodTrack)) return kFALSE;
  if (!fMuonTrackCuts->IsSelected(vparticle)) return kFALSE;
  HandleVParticle(vparticle);   if (!fTrack)  return kFALSE;
  return kTRUE;
}

//----------------------------------------------------------------------------//
Double_t AliFlowTrackCuts::GetPmdEta(Float_t xPos, Float_t yPos, Float_t zPos)
{
  //get PMD "track" eta coordinate
  Float_t rpxpy, theta, eta;
  rpxpy  = TMath::Sqrt(xPos*xPos + yPos*yPos);
  theta  = TMath::ATan2(rpxpy,zPos);
  eta    = -TMath::Log(TMath::Tan(0.5*theta));
  return eta;
}

//--------------------------------------------------------------------------//
Double_t AliFlowTrackCuts::GetPmdPhi(Float_t xPos, Float_t yPos)
{
  //Get PMD "track" phi coordinate
  Float_t pybypx, phi = 0., phi1;
  if(xPos==0)
    {
      if(yPos>0) phi = 90.;
      if(yPos<0) phi = 270.;
    }
  if(xPos != 0)
    {
      pybypx = yPos/xPos;
      if(pybypx < 0) pybypx = - pybypx;
      phi1 = TMath::ATan(pybypx)*180./3.14159;
      
      if(xPos > 0 && yPos > 0) phi = phi1;        // 1st Quadrant
      if(xPos < 0 && yPos > 0) phi = 180 - phi1;  // 2nd Quadrant
      if(xPos < 0 && yPos < 0) phi = 180 + phi1;  // 3rd Quadrant
      if(xPos > 0 && yPos < 0) phi = 360 - phi1;  // 4th Quadrant
      
    }
  phi = phi*3.14159/180.;
  return   phi;
}

//---------------------------------------------------------------//
void AliFlowTrackCuts::Browse(TBrowser* b)
{
  //some browsing capabilities
  if (fQA) b->Add(fQA);
}

//---------------------------------------------------------------//
Long64_t AliFlowTrackCuts::Merge(TCollection* list)
{
  //merge
  if (!fQA || !list) return 0;
  if (list->IsEmpty()) return 0;
  AliFlowTrackCuts* obj=NULL;
  TList tmplist;
  TIter next(list);
  while ( (obj = dynamic_cast<AliFlowTrackCuts*>(next())) )
  {
    if (obj==this) continue;
    tmplist.Add(obj->GetQA());
  }
  return fQA->Merge(&tmplist);
}



 AliFlowTrackCuts.cxx:1
 AliFlowTrackCuts.cxx:2
 AliFlowTrackCuts.cxx:3
 AliFlowTrackCuts.cxx:4
 AliFlowTrackCuts.cxx:5
 AliFlowTrackCuts.cxx:6
 AliFlowTrackCuts.cxx:7
 AliFlowTrackCuts.cxx:8
 AliFlowTrackCuts.cxx:9
 AliFlowTrackCuts.cxx:10
 AliFlowTrackCuts.cxx:11
 AliFlowTrackCuts.cxx:12
 AliFlowTrackCuts.cxx:13
 AliFlowTrackCuts.cxx:14
 AliFlowTrackCuts.cxx:15
 AliFlowTrackCuts.cxx:16
 AliFlowTrackCuts.cxx:17
 AliFlowTrackCuts.cxx:18
 AliFlowTrackCuts.cxx:19
 AliFlowTrackCuts.cxx:20
 AliFlowTrackCuts.cxx:21
 AliFlowTrackCuts.cxx:22
 AliFlowTrackCuts.cxx:23
 AliFlowTrackCuts.cxx:24
 AliFlowTrackCuts.cxx:25
 AliFlowTrackCuts.cxx:26
 AliFlowTrackCuts.cxx:27
 AliFlowTrackCuts.cxx:28
 AliFlowTrackCuts.cxx:29
 AliFlowTrackCuts.cxx:30
 AliFlowTrackCuts.cxx:31
 AliFlowTrackCuts.cxx:32
 AliFlowTrackCuts.cxx:33
 AliFlowTrackCuts.cxx:34
 AliFlowTrackCuts.cxx:35
 AliFlowTrackCuts.cxx:36
 AliFlowTrackCuts.cxx:37
 AliFlowTrackCuts.cxx:38
 AliFlowTrackCuts.cxx:39
 AliFlowTrackCuts.cxx:40
 AliFlowTrackCuts.cxx:41
 AliFlowTrackCuts.cxx:42
 AliFlowTrackCuts.cxx:43
 AliFlowTrackCuts.cxx:44
 AliFlowTrackCuts.cxx:45
 AliFlowTrackCuts.cxx:46
 AliFlowTrackCuts.cxx:47
 AliFlowTrackCuts.cxx:48
 AliFlowTrackCuts.cxx:49
 AliFlowTrackCuts.cxx:50
 AliFlowTrackCuts.cxx:51
 AliFlowTrackCuts.cxx:52
 AliFlowTrackCuts.cxx:53
 AliFlowTrackCuts.cxx:54
 AliFlowTrackCuts.cxx:55
 AliFlowTrackCuts.cxx:56
 AliFlowTrackCuts.cxx:57
 AliFlowTrackCuts.cxx:58
 AliFlowTrackCuts.cxx:59
 AliFlowTrackCuts.cxx:60
 AliFlowTrackCuts.cxx:61
 AliFlowTrackCuts.cxx:62
 AliFlowTrackCuts.cxx:63
 AliFlowTrackCuts.cxx:64
 AliFlowTrackCuts.cxx:65
 AliFlowTrackCuts.cxx:66
 AliFlowTrackCuts.cxx:67
 AliFlowTrackCuts.cxx:68
 AliFlowTrackCuts.cxx:69
 AliFlowTrackCuts.cxx:70
 AliFlowTrackCuts.cxx:71
 AliFlowTrackCuts.cxx:72
 AliFlowTrackCuts.cxx:73
 AliFlowTrackCuts.cxx:74
 AliFlowTrackCuts.cxx:75
 AliFlowTrackCuts.cxx:76
 AliFlowTrackCuts.cxx:77
 AliFlowTrackCuts.cxx:78
 AliFlowTrackCuts.cxx:79
 AliFlowTrackCuts.cxx:80
 AliFlowTrackCuts.cxx:81
 AliFlowTrackCuts.cxx:82
 AliFlowTrackCuts.cxx:83
 AliFlowTrackCuts.cxx:84
 AliFlowTrackCuts.cxx:85
 AliFlowTrackCuts.cxx:86
 AliFlowTrackCuts.cxx:87
 AliFlowTrackCuts.cxx:88
 AliFlowTrackCuts.cxx:89
 AliFlowTrackCuts.cxx:90
 AliFlowTrackCuts.cxx:91
 AliFlowTrackCuts.cxx:92
 AliFlowTrackCuts.cxx:93
 AliFlowTrackCuts.cxx:94
 AliFlowTrackCuts.cxx:95
 AliFlowTrackCuts.cxx:96
 AliFlowTrackCuts.cxx:97
 AliFlowTrackCuts.cxx:98
 AliFlowTrackCuts.cxx:99
 AliFlowTrackCuts.cxx:100
 AliFlowTrackCuts.cxx:101
 AliFlowTrackCuts.cxx:102
 AliFlowTrackCuts.cxx:103
 AliFlowTrackCuts.cxx:104
 AliFlowTrackCuts.cxx:105
 AliFlowTrackCuts.cxx:106
 AliFlowTrackCuts.cxx:107
 AliFlowTrackCuts.cxx:108
 AliFlowTrackCuts.cxx:109
 AliFlowTrackCuts.cxx:110
 AliFlowTrackCuts.cxx:111
 AliFlowTrackCuts.cxx:112
 AliFlowTrackCuts.cxx:113
 AliFlowTrackCuts.cxx:114
 AliFlowTrackCuts.cxx:115
 AliFlowTrackCuts.cxx:116
 AliFlowTrackCuts.cxx:117
 AliFlowTrackCuts.cxx:118
 AliFlowTrackCuts.cxx:119
 AliFlowTrackCuts.cxx:120
 AliFlowTrackCuts.cxx:121
 AliFlowTrackCuts.cxx:122
 AliFlowTrackCuts.cxx:123
 AliFlowTrackCuts.cxx:124
 AliFlowTrackCuts.cxx:125
 AliFlowTrackCuts.cxx:126
 AliFlowTrackCuts.cxx:127
 AliFlowTrackCuts.cxx:128
 AliFlowTrackCuts.cxx:129
 AliFlowTrackCuts.cxx:130
 AliFlowTrackCuts.cxx:131
 AliFlowTrackCuts.cxx:132
 AliFlowTrackCuts.cxx:133
 AliFlowTrackCuts.cxx:134
 AliFlowTrackCuts.cxx:135
 AliFlowTrackCuts.cxx:136
 AliFlowTrackCuts.cxx:137
 AliFlowTrackCuts.cxx:138
 AliFlowTrackCuts.cxx:139
 AliFlowTrackCuts.cxx:140
 AliFlowTrackCuts.cxx:141
 AliFlowTrackCuts.cxx:142
 AliFlowTrackCuts.cxx:143
 AliFlowTrackCuts.cxx:144
 AliFlowTrackCuts.cxx:145
 AliFlowTrackCuts.cxx:146
 AliFlowTrackCuts.cxx:147
 AliFlowTrackCuts.cxx:148
 AliFlowTrackCuts.cxx:149
 AliFlowTrackCuts.cxx:150
 AliFlowTrackCuts.cxx:151
 AliFlowTrackCuts.cxx:152
 AliFlowTrackCuts.cxx:153
 AliFlowTrackCuts.cxx:154
 AliFlowTrackCuts.cxx:155
 AliFlowTrackCuts.cxx:156
 AliFlowTrackCuts.cxx:157
 AliFlowTrackCuts.cxx:158
 AliFlowTrackCuts.cxx:159
 AliFlowTrackCuts.cxx:160
 AliFlowTrackCuts.cxx:161
 AliFlowTrackCuts.cxx:162
 AliFlowTrackCuts.cxx:163
 AliFlowTrackCuts.cxx:164
 AliFlowTrackCuts.cxx:165
 AliFlowTrackCuts.cxx:166
 AliFlowTrackCuts.cxx:167
 AliFlowTrackCuts.cxx:168
 AliFlowTrackCuts.cxx:169
 AliFlowTrackCuts.cxx:170
 AliFlowTrackCuts.cxx:171
 AliFlowTrackCuts.cxx:172
 AliFlowTrackCuts.cxx:173
 AliFlowTrackCuts.cxx:174
 AliFlowTrackCuts.cxx:175
 AliFlowTrackCuts.cxx:176
 AliFlowTrackCuts.cxx:177
 AliFlowTrackCuts.cxx:178
 AliFlowTrackCuts.cxx:179
 AliFlowTrackCuts.cxx:180
 AliFlowTrackCuts.cxx:181
 AliFlowTrackCuts.cxx:182
 AliFlowTrackCuts.cxx:183
 AliFlowTrackCuts.cxx:184
 AliFlowTrackCuts.cxx:185
 AliFlowTrackCuts.cxx:186
 AliFlowTrackCuts.cxx:187
 AliFlowTrackCuts.cxx:188
 AliFlowTrackCuts.cxx:189
 AliFlowTrackCuts.cxx:190
 AliFlowTrackCuts.cxx:191
 AliFlowTrackCuts.cxx:192
 AliFlowTrackCuts.cxx:193
 AliFlowTrackCuts.cxx:194
 AliFlowTrackCuts.cxx:195
 AliFlowTrackCuts.cxx:196
 AliFlowTrackCuts.cxx:197
 AliFlowTrackCuts.cxx:198
 AliFlowTrackCuts.cxx:199
 AliFlowTrackCuts.cxx:200
 AliFlowTrackCuts.cxx:201
 AliFlowTrackCuts.cxx:202
 AliFlowTrackCuts.cxx:203
 AliFlowTrackCuts.cxx:204
 AliFlowTrackCuts.cxx:205
 AliFlowTrackCuts.cxx:206
 AliFlowTrackCuts.cxx:207
 AliFlowTrackCuts.cxx:208
 AliFlowTrackCuts.cxx:209
 AliFlowTrackCuts.cxx:210
 AliFlowTrackCuts.cxx:211
 AliFlowTrackCuts.cxx:212
 AliFlowTrackCuts.cxx:213
 AliFlowTrackCuts.cxx:214
 AliFlowTrackCuts.cxx:215
 AliFlowTrackCuts.cxx:216
 AliFlowTrackCuts.cxx:217
 AliFlowTrackCuts.cxx:218
 AliFlowTrackCuts.cxx:219
 AliFlowTrackCuts.cxx:220
 AliFlowTrackCuts.cxx:221
 AliFlowTrackCuts.cxx:222
 AliFlowTrackCuts.cxx:223
 AliFlowTrackCuts.cxx:224
 AliFlowTrackCuts.cxx:225
 AliFlowTrackCuts.cxx:226
 AliFlowTrackCuts.cxx:227
 AliFlowTrackCuts.cxx:228
 AliFlowTrackCuts.cxx:229
 AliFlowTrackCuts.cxx:230
 AliFlowTrackCuts.cxx:231
 AliFlowTrackCuts.cxx:232
 AliFlowTrackCuts.cxx:233
 AliFlowTrackCuts.cxx:234
 AliFlowTrackCuts.cxx:235
 AliFlowTrackCuts.cxx:236
 AliFlowTrackCuts.cxx:237
 AliFlowTrackCuts.cxx:238
 AliFlowTrackCuts.cxx:239
 AliFlowTrackCuts.cxx:240
 AliFlowTrackCuts.cxx:241
 AliFlowTrackCuts.cxx:242
 AliFlowTrackCuts.cxx:243
 AliFlowTrackCuts.cxx:244
 AliFlowTrackCuts.cxx:245
 AliFlowTrackCuts.cxx:246
 AliFlowTrackCuts.cxx:247
 AliFlowTrackCuts.cxx:248
 AliFlowTrackCuts.cxx:249
 AliFlowTrackCuts.cxx:250
 AliFlowTrackCuts.cxx:251
 AliFlowTrackCuts.cxx:252
 AliFlowTrackCuts.cxx:253
 AliFlowTrackCuts.cxx:254
 AliFlowTrackCuts.cxx:255
 AliFlowTrackCuts.cxx:256
 AliFlowTrackCuts.cxx:257
 AliFlowTrackCuts.cxx:258
 AliFlowTrackCuts.cxx:259
 AliFlowTrackCuts.cxx:260
 AliFlowTrackCuts.cxx:261
 AliFlowTrackCuts.cxx:262
 AliFlowTrackCuts.cxx:263
 AliFlowTrackCuts.cxx:264
 AliFlowTrackCuts.cxx:265
 AliFlowTrackCuts.cxx:266
 AliFlowTrackCuts.cxx:267
 AliFlowTrackCuts.cxx:268
 AliFlowTrackCuts.cxx:269
 AliFlowTrackCuts.cxx:270
 AliFlowTrackCuts.cxx:271
 AliFlowTrackCuts.cxx:272
 AliFlowTrackCuts.cxx:273
 AliFlowTrackCuts.cxx:274
 AliFlowTrackCuts.cxx:275
 AliFlowTrackCuts.cxx:276
 AliFlowTrackCuts.cxx:277
 AliFlowTrackCuts.cxx:278
 AliFlowTrackCuts.cxx:279
 AliFlowTrackCuts.cxx:280
 AliFlowTrackCuts.cxx:281
 AliFlowTrackCuts.cxx:282
 AliFlowTrackCuts.cxx:283
 AliFlowTrackCuts.cxx:284
 AliFlowTrackCuts.cxx:285
 AliFlowTrackCuts.cxx:286
 AliFlowTrackCuts.cxx:287
 AliFlowTrackCuts.cxx:288
 AliFlowTrackCuts.cxx:289
 AliFlowTrackCuts.cxx:290
 AliFlowTrackCuts.cxx:291
 AliFlowTrackCuts.cxx:292
 AliFlowTrackCuts.cxx:293
 AliFlowTrackCuts.cxx:294
 AliFlowTrackCuts.cxx:295
 AliFlowTrackCuts.cxx:296
 AliFlowTrackCuts.cxx:297
 AliFlowTrackCuts.cxx:298
 AliFlowTrackCuts.cxx:299
 AliFlowTrackCuts.cxx:300
 AliFlowTrackCuts.cxx:301
 AliFlowTrackCuts.cxx:302
 AliFlowTrackCuts.cxx:303
 AliFlowTrackCuts.cxx:304
 AliFlowTrackCuts.cxx:305
 AliFlowTrackCuts.cxx:306
 AliFlowTrackCuts.cxx:307
 AliFlowTrackCuts.cxx:308
 AliFlowTrackCuts.cxx:309
 AliFlowTrackCuts.cxx:310
 AliFlowTrackCuts.cxx:311
 AliFlowTrackCuts.cxx:312
 AliFlowTrackCuts.cxx:313
 AliFlowTrackCuts.cxx:314
 AliFlowTrackCuts.cxx:315
 AliFlowTrackCuts.cxx:316
 AliFlowTrackCuts.cxx:317
 AliFlowTrackCuts.cxx:318
 AliFlowTrackCuts.cxx:319
 AliFlowTrackCuts.cxx:320
 AliFlowTrackCuts.cxx:321
 AliFlowTrackCuts.cxx:322
 AliFlowTrackCuts.cxx:323
 AliFlowTrackCuts.cxx:324
 AliFlowTrackCuts.cxx:325
 AliFlowTrackCuts.cxx:326
 AliFlowTrackCuts.cxx:327
 AliFlowTrackCuts.cxx:328
 AliFlowTrackCuts.cxx:329
 AliFlowTrackCuts.cxx:330
 AliFlowTrackCuts.cxx:331
 AliFlowTrackCuts.cxx:332
 AliFlowTrackCuts.cxx:333
 AliFlowTrackCuts.cxx:334
 AliFlowTrackCuts.cxx:335
 AliFlowTrackCuts.cxx:336
 AliFlowTrackCuts.cxx:337
 AliFlowTrackCuts.cxx:338
 AliFlowTrackCuts.cxx:339
 AliFlowTrackCuts.cxx:340
 AliFlowTrackCuts.cxx:341
 AliFlowTrackCuts.cxx:342
 AliFlowTrackCuts.cxx:343
 AliFlowTrackCuts.cxx:344
 AliFlowTrackCuts.cxx:345
 AliFlowTrackCuts.cxx:346
 AliFlowTrackCuts.cxx:347
 AliFlowTrackCuts.cxx:348
 AliFlowTrackCuts.cxx:349
 AliFlowTrackCuts.cxx:350
 AliFlowTrackCuts.cxx:351
 AliFlowTrackCuts.cxx:352
 AliFlowTrackCuts.cxx:353
 AliFlowTrackCuts.cxx:354
 AliFlowTrackCuts.cxx:355
 AliFlowTrackCuts.cxx:356
 AliFlowTrackCuts.cxx:357
 AliFlowTrackCuts.cxx:358
 AliFlowTrackCuts.cxx:359
 AliFlowTrackCuts.cxx:360
 AliFlowTrackCuts.cxx:361
 AliFlowTrackCuts.cxx:362
 AliFlowTrackCuts.cxx:363
 AliFlowTrackCuts.cxx:364
 AliFlowTrackCuts.cxx:365
 AliFlowTrackCuts.cxx:366
 AliFlowTrackCuts.cxx:367
 AliFlowTrackCuts.cxx:368
 AliFlowTrackCuts.cxx:369
 AliFlowTrackCuts.cxx:370
 AliFlowTrackCuts.cxx:371
 AliFlowTrackCuts.cxx:372
 AliFlowTrackCuts.cxx:373
 AliFlowTrackCuts.cxx:374
 AliFlowTrackCuts.cxx:375
 AliFlowTrackCuts.cxx:376
 AliFlowTrackCuts.cxx:377
 AliFlowTrackCuts.cxx:378
 AliFlowTrackCuts.cxx:379
 AliFlowTrackCuts.cxx:380
 AliFlowTrackCuts.cxx:381
 AliFlowTrackCuts.cxx:382
 AliFlowTrackCuts.cxx:383
 AliFlowTrackCuts.cxx:384
 AliFlowTrackCuts.cxx:385
 AliFlowTrackCuts.cxx:386
 AliFlowTrackCuts.cxx:387
 AliFlowTrackCuts.cxx:388
 AliFlowTrackCuts.cxx:389
 AliFlowTrackCuts.cxx:390
 AliFlowTrackCuts.cxx:391
 AliFlowTrackCuts.cxx:392
 AliFlowTrackCuts.cxx:393
 AliFlowTrackCuts.cxx:394
 AliFlowTrackCuts.cxx:395
 AliFlowTrackCuts.cxx:396
 AliFlowTrackCuts.cxx:397
 AliFlowTrackCuts.cxx:398
 AliFlowTrackCuts.cxx:399
 AliFlowTrackCuts.cxx:400
 AliFlowTrackCuts.cxx:401
 AliFlowTrackCuts.cxx:402
 AliFlowTrackCuts.cxx:403
 AliFlowTrackCuts.cxx:404
 AliFlowTrackCuts.cxx:405
 AliFlowTrackCuts.cxx:406
 AliFlowTrackCuts.cxx:407
 AliFlowTrackCuts.cxx:408
 AliFlowTrackCuts.cxx:409
 AliFlowTrackCuts.cxx:410
 AliFlowTrackCuts.cxx:411
 AliFlowTrackCuts.cxx:412
 AliFlowTrackCuts.cxx:413
 AliFlowTrackCuts.cxx:414
 AliFlowTrackCuts.cxx:415
 AliFlowTrackCuts.cxx:416
 AliFlowTrackCuts.cxx:417
 AliFlowTrackCuts.cxx:418
 AliFlowTrackCuts.cxx:419
 AliFlowTrackCuts.cxx:420
 AliFlowTrackCuts.cxx:421
 AliFlowTrackCuts.cxx:422
 AliFlowTrackCuts.cxx:423
 AliFlowTrackCuts.cxx:424
 AliFlowTrackCuts.cxx:425
 AliFlowTrackCuts.cxx:426
 AliFlowTrackCuts.cxx:427
 AliFlowTrackCuts.cxx:428
 AliFlowTrackCuts.cxx:429
 AliFlowTrackCuts.cxx:430
 AliFlowTrackCuts.cxx:431
 AliFlowTrackCuts.cxx:432
 AliFlowTrackCuts.cxx:433
 AliFlowTrackCuts.cxx:434
 AliFlowTrackCuts.cxx:435
 AliFlowTrackCuts.cxx:436
 AliFlowTrackCuts.cxx:437
 AliFlowTrackCuts.cxx:438
 AliFlowTrackCuts.cxx:439
 AliFlowTrackCuts.cxx:440
 AliFlowTrackCuts.cxx:441
 AliFlowTrackCuts.cxx:442
 AliFlowTrackCuts.cxx:443
 AliFlowTrackCuts.cxx:444
 AliFlowTrackCuts.cxx:445
 AliFlowTrackCuts.cxx:446
 AliFlowTrackCuts.cxx:447
 AliFlowTrackCuts.cxx:448
 AliFlowTrackCuts.cxx:449
 AliFlowTrackCuts.cxx:450
 AliFlowTrackCuts.cxx:451
 AliFlowTrackCuts.cxx:452
 AliFlowTrackCuts.cxx:453
 AliFlowTrackCuts.cxx:454
 AliFlowTrackCuts.cxx:455
 AliFlowTrackCuts.cxx:456
 AliFlowTrackCuts.cxx:457
 AliFlowTrackCuts.cxx:458
 AliFlowTrackCuts.cxx:459
 AliFlowTrackCuts.cxx:460
 AliFlowTrackCuts.cxx:461
 AliFlowTrackCuts.cxx:462
 AliFlowTrackCuts.cxx:463
 AliFlowTrackCuts.cxx:464
 AliFlowTrackCuts.cxx:465
 AliFlowTrackCuts.cxx:466
 AliFlowTrackCuts.cxx:467
 AliFlowTrackCuts.cxx:468
 AliFlowTrackCuts.cxx:469
 AliFlowTrackCuts.cxx:470
 AliFlowTrackCuts.cxx:471
 AliFlowTrackCuts.cxx:472
 AliFlowTrackCuts.cxx:473
 AliFlowTrackCuts.cxx:474
 AliFlowTrackCuts.cxx:475
 AliFlowTrackCuts.cxx:476
 AliFlowTrackCuts.cxx:477
 AliFlowTrackCuts.cxx:478
 AliFlowTrackCuts.cxx:479
 AliFlowTrackCuts.cxx:480
 AliFlowTrackCuts.cxx:481
 AliFlowTrackCuts.cxx:482
 AliFlowTrackCuts.cxx:483
 AliFlowTrackCuts.cxx:484
 AliFlowTrackCuts.cxx:485
 AliFlowTrackCuts.cxx:486
 AliFlowTrackCuts.cxx:487
 AliFlowTrackCuts.cxx:488
 AliFlowTrackCuts.cxx:489
 AliFlowTrackCuts.cxx:490
 AliFlowTrackCuts.cxx:491
 AliFlowTrackCuts.cxx:492
 AliFlowTrackCuts.cxx:493
 AliFlowTrackCuts.cxx:494
 AliFlowTrackCuts.cxx:495
 AliFlowTrackCuts.cxx:496
 AliFlowTrackCuts.cxx:497
 AliFlowTrackCuts.cxx:498
 AliFlowTrackCuts.cxx:499
 AliFlowTrackCuts.cxx:500
 AliFlowTrackCuts.cxx:501
 AliFlowTrackCuts.cxx:502
 AliFlowTrackCuts.cxx:503
 AliFlowTrackCuts.cxx:504
 AliFlowTrackCuts.cxx:505
 AliFlowTrackCuts.cxx:506
 AliFlowTrackCuts.cxx:507
 AliFlowTrackCuts.cxx:508
 AliFlowTrackCuts.cxx:509
 AliFlowTrackCuts.cxx:510
 AliFlowTrackCuts.cxx:511
 AliFlowTrackCuts.cxx:512
 AliFlowTrackCuts.cxx:513
 AliFlowTrackCuts.cxx:514
 AliFlowTrackCuts.cxx:515
 AliFlowTrackCuts.cxx:516
 AliFlowTrackCuts.cxx:517
 AliFlowTrackCuts.cxx:518
 AliFlowTrackCuts.cxx:519
 AliFlowTrackCuts.cxx:520
 AliFlowTrackCuts.cxx:521
 AliFlowTrackCuts.cxx:522
 AliFlowTrackCuts.cxx:523
 AliFlowTrackCuts.cxx:524
 AliFlowTrackCuts.cxx:525
 AliFlowTrackCuts.cxx:526
 AliFlowTrackCuts.cxx:527
 AliFlowTrackCuts.cxx:528
 AliFlowTrackCuts.cxx:529
 AliFlowTrackCuts.cxx:530
 AliFlowTrackCuts.cxx:531
 AliFlowTrackCuts.cxx:532
 AliFlowTrackCuts.cxx:533
 AliFlowTrackCuts.cxx:534
 AliFlowTrackCuts.cxx:535
 AliFlowTrackCuts.cxx:536
 AliFlowTrackCuts.cxx:537
 AliFlowTrackCuts.cxx:538
 AliFlowTrackCuts.cxx:539
 AliFlowTrackCuts.cxx:540
 AliFlowTrackCuts.cxx:541
 AliFlowTrackCuts.cxx:542
 AliFlowTrackCuts.cxx:543
 AliFlowTrackCuts.cxx:544
 AliFlowTrackCuts.cxx:545
 AliFlowTrackCuts.cxx:546
 AliFlowTrackCuts.cxx:547
 AliFlowTrackCuts.cxx:548
 AliFlowTrackCuts.cxx:549
 AliFlowTrackCuts.cxx:550
 AliFlowTrackCuts.cxx:551
 AliFlowTrackCuts.cxx:552
 AliFlowTrackCuts.cxx:553
 AliFlowTrackCuts.cxx:554
 AliFlowTrackCuts.cxx:555
 AliFlowTrackCuts.cxx:556
 AliFlowTrackCuts.cxx:557
 AliFlowTrackCuts.cxx:558
 AliFlowTrackCuts.cxx:559
 AliFlowTrackCuts.cxx:560
 AliFlowTrackCuts.cxx:561
 AliFlowTrackCuts.cxx:562
 AliFlowTrackCuts.cxx:563
 AliFlowTrackCuts.cxx:564
 AliFlowTrackCuts.cxx:565
 AliFlowTrackCuts.cxx:566
 AliFlowTrackCuts.cxx:567
 AliFlowTrackCuts.cxx:568
 AliFlowTrackCuts.cxx:569
 AliFlowTrackCuts.cxx:570
 AliFlowTrackCuts.cxx:571
 AliFlowTrackCuts.cxx:572
 AliFlowTrackCuts.cxx:573
 AliFlowTrackCuts.cxx:574
 AliFlowTrackCuts.cxx:575
 AliFlowTrackCuts.cxx:576
 AliFlowTrackCuts.cxx:577
 AliFlowTrackCuts.cxx:578
 AliFlowTrackCuts.cxx:579
 AliFlowTrackCuts.cxx:580
 AliFlowTrackCuts.cxx:581
 AliFlowTrackCuts.cxx:582
 AliFlowTrackCuts.cxx:583
 AliFlowTrackCuts.cxx:584
 AliFlowTrackCuts.cxx:585
 AliFlowTrackCuts.cxx:586
 AliFlowTrackCuts.cxx:587
 AliFlowTrackCuts.cxx:588
 AliFlowTrackCuts.cxx:589
 AliFlowTrackCuts.cxx:590
 AliFlowTrackCuts.cxx:591
 AliFlowTrackCuts.cxx:592
 AliFlowTrackCuts.cxx:593
 AliFlowTrackCuts.cxx:594
 AliFlowTrackCuts.cxx:595
 AliFlowTrackCuts.cxx:596
 AliFlowTrackCuts.cxx:597
 AliFlowTrackCuts.cxx:598
 AliFlowTrackCuts.cxx:599
 AliFlowTrackCuts.cxx:600
 AliFlowTrackCuts.cxx:601
 AliFlowTrackCuts.cxx:602
 AliFlowTrackCuts.cxx:603
 AliFlowTrackCuts.cxx:604
 AliFlowTrackCuts.cxx:605
 AliFlowTrackCuts.cxx:606
 AliFlowTrackCuts.cxx:607
 AliFlowTrackCuts.cxx:608
 AliFlowTrackCuts.cxx:609
 AliFlowTrackCuts.cxx:610
 AliFlowTrackCuts.cxx:611
 AliFlowTrackCuts.cxx:612
 AliFlowTrackCuts.cxx:613
 AliFlowTrackCuts.cxx:614
 AliFlowTrackCuts.cxx:615
 AliFlowTrackCuts.cxx:616
 AliFlowTrackCuts.cxx:617
 AliFlowTrackCuts.cxx:618
 AliFlowTrackCuts.cxx:619
 AliFlowTrackCuts.cxx:620
 AliFlowTrackCuts.cxx:621
 AliFlowTrackCuts.cxx:622
 AliFlowTrackCuts.cxx:623
 AliFlowTrackCuts.cxx:624
 AliFlowTrackCuts.cxx:625
 AliFlowTrackCuts.cxx:626
 AliFlowTrackCuts.cxx:627
 AliFlowTrackCuts.cxx:628
 AliFlowTrackCuts.cxx:629
 AliFlowTrackCuts.cxx:630
 AliFlowTrackCuts.cxx:631
 AliFlowTrackCuts.cxx:632
 AliFlowTrackCuts.cxx:633
 AliFlowTrackCuts.cxx:634
 AliFlowTrackCuts.cxx:635
 AliFlowTrackCuts.cxx:636
 AliFlowTrackCuts.cxx:637
 AliFlowTrackCuts.cxx:638
 AliFlowTrackCuts.cxx:639
 AliFlowTrackCuts.cxx:640
 AliFlowTrackCuts.cxx:641
 AliFlowTrackCuts.cxx:642
 AliFlowTrackCuts.cxx:643
 AliFlowTrackCuts.cxx:644
 AliFlowTrackCuts.cxx:645
 AliFlowTrackCuts.cxx:646
 AliFlowTrackCuts.cxx:647
 AliFlowTrackCuts.cxx:648
 AliFlowTrackCuts.cxx:649
 AliFlowTrackCuts.cxx:650
 AliFlowTrackCuts.cxx:651
 AliFlowTrackCuts.cxx:652
 AliFlowTrackCuts.cxx:653
 AliFlowTrackCuts.cxx:654
 AliFlowTrackCuts.cxx:655
 AliFlowTrackCuts.cxx:656
 AliFlowTrackCuts.cxx:657
 AliFlowTrackCuts.cxx:658
 AliFlowTrackCuts.cxx:659
 AliFlowTrackCuts.cxx:660
 AliFlowTrackCuts.cxx:661
 AliFlowTrackCuts.cxx:662
 AliFlowTrackCuts.cxx:663
 AliFlowTrackCuts.cxx:664
 AliFlowTrackCuts.cxx:665
 AliFlowTrackCuts.cxx:666
 AliFlowTrackCuts.cxx:667
 AliFlowTrackCuts.cxx:668
 AliFlowTrackCuts.cxx:669
 AliFlowTrackCuts.cxx:670
 AliFlowTrackCuts.cxx:671
 AliFlowTrackCuts.cxx:672
 AliFlowTrackCuts.cxx:673
 AliFlowTrackCuts.cxx:674
 AliFlowTrackCuts.cxx:675
 AliFlowTrackCuts.cxx:676
 AliFlowTrackCuts.cxx:677
 AliFlowTrackCuts.cxx:678
 AliFlowTrackCuts.cxx:679
 AliFlowTrackCuts.cxx:680
 AliFlowTrackCuts.cxx:681
 AliFlowTrackCuts.cxx:682
 AliFlowTrackCuts.cxx:683
 AliFlowTrackCuts.cxx:684
 AliFlowTrackCuts.cxx:685
 AliFlowTrackCuts.cxx:686
 AliFlowTrackCuts.cxx:687
 AliFlowTrackCuts.cxx:688
 AliFlowTrackCuts.cxx:689
 AliFlowTrackCuts.cxx:690
 AliFlowTrackCuts.cxx:691
 AliFlowTrackCuts.cxx:692
 AliFlowTrackCuts.cxx:693
 AliFlowTrackCuts.cxx:694
 AliFlowTrackCuts.cxx:695
 AliFlowTrackCuts.cxx:696
 AliFlowTrackCuts.cxx:697
 AliFlowTrackCuts.cxx:698
 AliFlowTrackCuts.cxx:699
 AliFlowTrackCuts.cxx:700
 AliFlowTrackCuts.cxx:701
 AliFlowTrackCuts.cxx:702
 AliFlowTrackCuts.cxx:703
 AliFlowTrackCuts.cxx:704
 AliFlowTrackCuts.cxx:705
 AliFlowTrackCuts.cxx:706
 AliFlowTrackCuts.cxx:707
 AliFlowTrackCuts.cxx:708
 AliFlowTrackCuts.cxx:709
 AliFlowTrackCuts.cxx:710
 AliFlowTrackCuts.cxx:711
 AliFlowTrackCuts.cxx:712
 AliFlowTrackCuts.cxx:713
 AliFlowTrackCuts.cxx:714
 AliFlowTrackCuts.cxx:715
 AliFlowTrackCuts.cxx:716
 AliFlowTrackCuts.cxx:717
 AliFlowTrackCuts.cxx:718
 AliFlowTrackCuts.cxx:719
 AliFlowTrackCuts.cxx:720
 AliFlowTrackCuts.cxx:721
 AliFlowTrackCuts.cxx:722
 AliFlowTrackCuts.cxx:723
 AliFlowTrackCuts.cxx:724
 AliFlowTrackCuts.cxx:725
 AliFlowTrackCuts.cxx:726
 AliFlowTrackCuts.cxx:727
 AliFlowTrackCuts.cxx:728
 AliFlowTrackCuts.cxx:729
 AliFlowTrackCuts.cxx:730
 AliFlowTrackCuts.cxx:731
 AliFlowTrackCuts.cxx:732
 AliFlowTrackCuts.cxx:733
 AliFlowTrackCuts.cxx:734
 AliFlowTrackCuts.cxx:735
 AliFlowTrackCuts.cxx:736
 AliFlowTrackCuts.cxx:737
 AliFlowTrackCuts.cxx:738
 AliFlowTrackCuts.cxx:739
 AliFlowTrackCuts.cxx:740
 AliFlowTrackCuts.cxx:741
 AliFlowTrackCuts.cxx:742
 AliFlowTrackCuts.cxx:743
 AliFlowTrackCuts.cxx:744
 AliFlowTrackCuts.cxx:745
 AliFlowTrackCuts.cxx:746
 AliFlowTrackCuts.cxx:747
 AliFlowTrackCuts.cxx:748
 AliFlowTrackCuts.cxx:749
 AliFlowTrackCuts.cxx:750
 AliFlowTrackCuts.cxx:751
 AliFlowTrackCuts.cxx:752
 AliFlowTrackCuts.cxx:753
 AliFlowTrackCuts.cxx:754
 AliFlowTrackCuts.cxx:755
 AliFlowTrackCuts.cxx:756
 AliFlowTrackCuts.cxx:757
 AliFlowTrackCuts.cxx:758
 AliFlowTrackCuts.cxx:759
 AliFlowTrackCuts.cxx:760
 AliFlowTrackCuts.cxx:761
 AliFlowTrackCuts.cxx:762
 AliFlowTrackCuts.cxx:763
 AliFlowTrackCuts.cxx:764
 AliFlowTrackCuts.cxx:765
 AliFlowTrackCuts.cxx:766
 AliFlowTrackCuts.cxx:767
 AliFlowTrackCuts.cxx:768
 AliFlowTrackCuts.cxx:769
 AliFlowTrackCuts.cxx:770
 AliFlowTrackCuts.cxx:771
 AliFlowTrackCuts.cxx:772
 AliFlowTrackCuts.cxx:773
 AliFlowTrackCuts.cxx:774
 AliFlowTrackCuts.cxx:775
 AliFlowTrackCuts.cxx:776
 AliFlowTrackCuts.cxx:777
 AliFlowTrackCuts.cxx:778
 AliFlowTrackCuts.cxx:779
 AliFlowTrackCuts.cxx:780
 AliFlowTrackCuts.cxx:781
 AliFlowTrackCuts.cxx:782
 AliFlowTrackCuts.cxx:783
 AliFlowTrackCuts.cxx:784
 AliFlowTrackCuts.cxx:785
 AliFlowTrackCuts.cxx:786
 AliFlowTrackCuts.cxx:787
 AliFlowTrackCuts.cxx:788
 AliFlowTrackCuts.cxx:789
 AliFlowTrackCuts.cxx:790
 AliFlowTrackCuts.cxx:791
 AliFlowTrackCuts.cxx:792
 AliFlowTrackCuts.cxx:793
 AliFlowTrackCuts.cxx:794
 AliFlowTrackCuts.cxx:795
 AliFlowTrackCuts.cxx:796
 AliFlowTrackCuts.cxx:797
 AliFlowTrackCuts.cxx:798
 AliFlowTrackCuts.cxx:799
 AliFlowTrackCuts.cxx:800
 AliFlowTrackCuts.cxx:801
 AliFlowTrackCuts.cxx:802
 AliFlowTrackCuts.cxx:803
 AliFlowTrackCuts.cxx:804
 AliFlowTrackCuts.cxx:805
 AliFlowTrackCuts.cxx:806
 AliFlowTrackCuts.cxx:807
 AliFlowTrackCuts.cxx:808
 AliFlowTrackCuts.cxx:809
 AliFlowTrackCuts.cxx:810
 AliFlowTrackCuts.cxx:811
 AliFlowTrackCuts.cxx:812
 AliFlowTrackCuts.cxx:813
 AliFlowTrackCuts.cxx:814
 AliFlowTrackCuts.cxx:815
 AliFlowTrackCuts.cxx:816
 AliFlowTrackCuts.cxx:817
 AliFlowTrackCuts.cxx:818
 AliFlowTrackCuts.cxx:819
 AliFlowTrackCuts.cxx:820
 AliFlowTrackCuts.cxx:821
 AliFlowTrackCuts.cxx:822
 AliFlowTrackCuts.cxx:823
 AliFlowTrackCuts.cxx:824
 AliFlowTrackCuts.cxx:825
 AliFlowTrackCuts.cxx:826
 AliFlowTrackCuts.cxx:827
 AliFlowTrackCuts.cxx:828
 AliFlowTrackCuts.cxx:829
 AliFlowTrackCuts.cxx:830
 AliFlowTrackCuts.cxx:831
 AliFlowTrackCuts.cxx:832
 AliFlowTrackCuts.cxx:833
 AliFlowTrackCuts.cxx:834
 AliFlowTrackCuts.cxx:835
 AliFlowTrackCuts.cxx:836
 AliFlowTrackCuts.cxx:837
 AliFlowTrackCuts.cxx:838
 AliFlowTrackCuts.cxx:839
 AliFlowTrackCuts.cxx:840
 AliFlowTrackCuts.cxx:841
 AliFlowTrackCuts.cxx:842
 AliFlowTrackCuts.cxx:843
 AliFlowTrackCuts.cxx:844
 AliFlowTrackCuts.cxx:845
 AliFlowTrackCuts.cxx:846
 AliFlowTrackCuts.cxx:847
 AliFlowTrackCuts.cxx:848
 AliFlowTrackCuts.cxx:849
 AliFlowTrackCuts.cxx:850
 AliFlowTrackCuts.cxx:851
 AliFlowTrackCuts.cxx:852
 AliFlowTrackCuts.cxx:853
 AliFlowTrackCuts.cxx:854
 AliFlowTrackCuts.cxx:855
 AliFlowTrackCuts.cxx:856
 AliFlowTrackCuts.cxx:857
 AliFlowTrackCuts.cxx:858
 AliFlowTrackCuts.cxx:859
 AliFlowTrackCuts.cxx:860
 AliFlowTrackCuts.cxx:861
 AliFlowTrackCuts.cxx:862
 AliFlowTrackCuts.cxx:863
 AliFlowTrackCuts.cxx:864
 AliFlowTrackCuts.cxx:865
 AliFlowTrackCuts.cxx:866
 AliFlowTrackCuts.cxx:867
 AliFlowTrackCuts.cxx:868
 AliFlowTrackCuts.cxx:869
 AliFlowTrackCuts.cxx:870
 AliFlowTrackCuts.cxx:871
 AliFlowTrackCuts.cxx:872
 AliFlowTrackCuts.cxx:873
 AliFlowTrackCuts.cxx:874
 AliFlowTrackCuts.cxx:875
 AliFlowTrackCuts.cxx:876
 AliFlowTrackCuts.cxx:877
 AliFlowTrackCuts.cxx:878
 AliFlowTrackCuts.cxx:879
 AliFlowTrackCuts.cxx:880
 AliFlowTrackCuts.cxx:881
 AliFlowTrackCuts.cxx:882
 AliFlowTrackCuts.cxx:883
 AliFlowTrackCuts.cxx:884
 AliFlowTrackCuts.cxx:885
 AliFlowTrackCuts.cxx:886
 AliFlowTrackCuts.cxx:887
 AliFlowTrackCuts.cxx:888
 AliFlowTrackCuts.cxx:889
 AliFlowTrackCuts.cxx:890
 AliFlowTrackCuts.cxx:891
 AliFlowTrackCuts.cxx:892
 AliFlowTrackCuts.cxx:893
 AliFlowTrackCuts.cxx:894
 AliFlowTrackCuts.cxx:895
 AliFlowTrackCuts.cxx:896
 AliFlowTrackCuts.cxx:897
 AliFlowTrackCuts.cxx:898
 AliFlowTrackCuts.cxx:899
 AliFlowTrackCuts.cxx:900
 AliFlowTrackCuts.cxx:901
 AliFlowTrackCuts.cxx:902
 AliFlowTrackCuts.cxx:903
 AliFlowTrackCuts.cxx:904
 AliFlowTrackCuts.cxx:905
 AliFlowTrackCuts.cxx:906
 AliFlowTrackCuts.cxx:907
 AliFlowTrackCuts.cxx:908
 AliFlowTrackCuts.cxx:909
 AliFlowTrackCuts.cxx:910
 AliFlowTrackCuts.cxx:911
 AliFlowTrackCuts.cxx:912
 AliFlowTrackCuts.cxx:913
 AliFlowTrackCuts.cxx:914
 AliFlowTrackCuts.cxx:915
 AliFlowTrackCuts.cxx:916
 AliFlowTrackCuts.cxx:917
 AliFlowTrackCuts.cxx:918
 AliFlowTrackCuts.cxx:919
 AliFlowTrackCuts.cxx:920
 AliFlowTrackCuts.cxx:921
 AliFlowTrackCuts.cxx:922
 AliFlowTrackCuts.cxx:923
 AliFlowTrackCuts.cxx:924
 AliFlowTrackCuts.cxx:925
 AliFlowTrackCuts.cxx:926
 AliFlowTrackCuts.cxx:927
 AliFlowTrackCuts.cxx:928
 AliFlowTrackCuts.cxx:929
 AliFlowTrackCuts.cxx:930
 AliFlowTrackCuts.cxx:931
 AliFlowTrackCuts.cxx:932
 AliFlowTrackCuts.cxx:933
 AliFlowTrackCuts.cxx:934
 AliFlowTrackCuts.cxx:935
 AliFlowTrackCuts.cxx:936
 AliFlowTrackCuts.cxx:937
 AliFlowTrackCuts.cxx:938
 AliFlowTrackCuts.cxx:939
 AliFlowTrackCuts.cxx:940
 AliFlowTrackCuts.cxx:941
 AliFlowTrackCuts.cxx:942
 AliFlowTrackCuts.cxx:943
 AliFlowTrackCuts.cxx:944
 AliFlowTrackCuts.cxx:945
 AliFlowTrackCuts.cxx:946
 AliFlowTrackCuts.cxx:947
 AliFlowTrackCuts.cxx:948
 AliFlowTrackCuts.cxx:949
 AliFlowTrackCuts.cxx:950
 AliFlowTrackCuts.cxx:951
 AliFlowTrackCuts.cxx:952
 AliFlowTrackCuts.cxx:953
 AliFlowTrackCuts.cxx:954
 AliFlowTrackCuts.cxx:955
 AliFlowTrackCuts.cxx:956
 AliFlowTrackCuts.cxx:957
 AliFlowTrackCuts.cxx:958
 AliFlowTrackCuts.cxx:959
 AliFlowTrackCuts.cxx:960
 AliFlowTrackCuts.cxx:961
 AliFlowTrackCuts.cxx:962
 AliFlowTrackCuts.cxx:963
 AliFlowTrackCuts.cxx:964
 AliFlowTrackCuts.cxx:965
 AliFlowTrackCuts.cxx:966
 AliFlowTrackCuts.cxx:967
 AliFlowTrackCuts.cxx:968
 AliFlowTrackCuts.cxx:969
 AliFlowTrackCuts.cxx:970
 AliFlowTrackCuts.cxx:971
 AliFlowTrackCuts.cxx:972
 AliFlowTrackCuts.cxx:973
 AliFlowTrackCuts.cxx:974
 AliFlowTrackCuts.cxx:975
 AliFlowTrackCuts.cxx:976
 AliFlowTrackCuts.cxx:977
 AliFlowTrackCuts.cxx:978
 AliFlowTrackCuts.cxx:979
 AliFlowTrackCuts.cxx:980
 AliFlowTrackCuts.cxx:981
 AliFlowTrackCuts.cxx:982
 AliFlowTrackCuts.cxx:983
 AliFlowTrackCuts.cxx:984
 AliFlowTrackCuts.cxx:985
 AliFlowTrackCuts.cxx:986
 AliFlowTrackCuts.cxx:987
 AliFlowTrackCuts.cxx:988
 AliFlowTrackCuts.cxx:989
 AliFlowTrackCuts.cxx:990
 AliFlowTrackCuts.cxx:991
 AliFlowTrackCuts.cxx:992
 AliFlowTrackCuts.cxx:993
 AliFlowTrackCuts.cxx:994
 AliFlowTrackCuts.cxx:995
 AliFlowTrackCuts.cxx:996
 AliFlowTrackCuts.cxx:997
 AliFlowTrackCuts.cxx:998
 AliFlowTrackCuts.cxx:999
 AliFlowTrackCuts.cxx:1000
 AliFlowTrackCuts.cxx:1001
 AliFlowTrackCuts.cxx:1002
 AliFlowTrackCuts.cxx:1003
 AliFlowTrackCuts.cxx:1004
 AliFlowTrackCuts.cxx:1005
 AliFlowTrackCuts.cxx:1006
 AliFlowTrackCuts.cxx:1007
 AliFlowTrackCuts.cxx:1008
 AliFlowTrackCuts.cxx:1009
 AliFlowTrackCuts.cxx:1010
 AliFlowTrackCuts.cxx:1011
 AliFlowTrackCuts.cxx:1012
 AliFlowTrackCuts.cxx:1013
 AliFlowTrackCuts.cxx:1014
 AliFlowTrackCuts.cxx:1015
 AliFlowTrackCuts.cxx:1016
 AliFlowTrackCuts.cxx:1017
 AliFlowTrackCuts.cxx:1018
 AliFlowTrackCuts.cxx:1019
 AliFlowTrackCuts.cxx:1020
 AliFlowTrackCuts.cxx:1021
 AliFlowTrackCuts.cxx:1022
 AliFlowTrackCuts.cxx:1023
 AliFlowTrackCuts.cxx:1024
 AliFlowTrackCuts.cxx:1025
 AliFlowTrackCuts.cxx:1026
 AliFlowTrackCuts.cxx:1027
 AliFlowTrackCuts.cxx:1028
 AliFlowTrackCuts.cxx:1029
 AliFlowTrackCuts.cxx:1030
 AliFlowTrackCuts.cxx:1031
 AliFlowTrackCuts.cxx:1032
 AliFlowTrackCuts.cxx:1033
 AliFlowTrackCuts.cxx:1034
 AliFlowTrackCuts.cxx:1035
 AliFlowTrackCuts.cxx:1036
 AliFlowTrackCuts.cxx:1037
 AliFlowTrackCuts.cxx:1038
 AliFlowTrackCuts.cxx:1039
 AliFlowTrackCuts.cxx:1040
 AliFlowTrackCuts.cxx:1041
 AliFlowTrackCuts.cxx:1042
 AliFlowTrackCuts.cxx:1043
 AliFlowTrackCuts.cxx:1044
 AliFlowTrackCuts.cxx:1045
 AliFlowTrackCuts.cxx:1046
 AliFlowTrackCuts.cxx:1047
 AliFlowTrackCuts.cxx:1048
 AliFlowTrackCuts.cxx:1049
 AliFlowTrackCuts.cxx:1050
 AliFlowTrackCuts.cxx:1051
 AliFlowTrackCuts.cxx:1052
 AliFlowTrackCuts.cxx:1053
 AliFlowTrackCuts.cxx:1054
 AliFlowTrackCuts.cxx:1055
 AliFlowTrackCuts.cxx:1056
 AliFlowTrackCuts.cxx:1057
 AliFlowTrackCuts.cxx:1058
 AliFlowTrackCuts.cxx:1059
 AliFlowTrackCuts.cxx:1060
 AliFlowTrackCuts.cxx:1061
 AliFlowTrackCuts.cxx:1062
 AliFlowTrackCuts.cxx:1063
 AliFlowTrackCuts.cxx:1064
 AliFlowTrackCuts.cxx:1065
 AliFlowTrackCuts.cxx:1066
 AliFlowTrackCuts.cxx:1067
 AliFlowTrackCuts.cxx:1068
 AliFlowTrackCuts.cxx:1069
 AliFlowTrackCuts.cxx:1070
 AliFlowTrackCuts.cxx:1071
 AliFlowTrackCuts.cxx:1072
 AliFlowTrackCuts.cxx:1073
 AliFlowTrackCuts.cxx:1074
 AliFlowTrackCuts.cxx:1075
 AliFlowTrackCuts.cxx:1076
 AliFlowTrackCuts.cxx:1077
 AliFlowTrackCuts.cxx:1078
 AliFlowTrackCuts.cxx:1079
 AliFlowTrackCuts.cxx:1080
 AliFlowTrackCuts.cxx:1081
 AliFlowTrackCuts.cxx:1082
 AliFlowTrackCuts.cxx:1083
 AliFlowTrackCuts.cxx:1084
 AliFlowTrackCuts.cxx:1085
 AliFlowTrackCuts.cxx:1086
 AliFlowTrackCuts.cxx:1087
 AliFlowTrackCuts.cxx:1088
 AliFlowTrackCuts.cxx:1089
 AliFlowTrackCuts.cxx:1090
 AliFlowTrackCuts.cxx:1091
 AliFlowTrackCuts.cxx:1092
 AliFlowTrackCuts.cxx:1093
 AliFlowTrackCuts.cxx:1094
 AliFlowTrackCuts.cxx:1095
 AliFlowTrackCuts.cxx:1096
 AliFlowTrackCuts.cxx:1097
 AliFlowTrackCuts.cxx:1098
 AliFlowTrackCuts.cxx:1099
 AliFlowTrackCuts.cxx:1100
 AliFlowTrackCuts.cxx:1101
 AliFlowTrackCuts.cxx:1102
 AliFlowTrackCuts.cxx:1103
 AliFlowTrackCuts.cxx:1104
 AliFlowTrackCuts.cxx:1105
 AliFlowTrackCuts.cxx:1106
 AliFlowTrackCuts.cxx:1107
 AliFlowTrackCuts.cxx:1108
 AliFlowTrackCuts.cxx:1109
 AliFlowTrackCuts.cxx:1110
 AliFlowTrackCuts.cxx:1111
 AliFlowTrackCuts.cxx:1112
 AliFlowTrackCuts.cxx:1113
 AliFlowTrackCuts.cxx:1114
 AliFlowTrackCuts.cxx:1115
 AliFlowTrackCuts.cxx:1116
 AliFlowTrackCuts.cxx:1117
 AliFlowTrackCuts.cxx:1118
 AliFlowTrackCuts.cxx:1119
 AliFlowTrackCuts.cxx:1120
 AliFlowTrackCuts.cxx:1121
 AliFlowTrackCuts.cxx:1122
 AliFlowTrackCuts.cxx:1123
 AliFlowTrackCuts.cxx:1124
 AliFlowTrackCuts.cxx:1125
 AliFlowTrackCuts.cxx:1126
 AliFlowTrackCuts.cxx:1127
 AliFlowTrackCuts.cxx:1128
 AliFlowTrackCuts.cxx:1129
 AliFlowTrackCuts.cxx:1130
 AliFlowTrackCuts.cxx:1131
 AliFlowTrackCuts.cxx:1132
 AliFlowTrackCuts.cxx:1133
 AliFlowTrackCuts.cxx:1134
 AliFlowTrackCuts.cxx:1135
 AliFlowTrackCuts.cxx:1136
 AliFlowTrackCuts.cxx:1137
 AliFlowTrackCuts.cxx:1138
 AliFlowTrackCuts.cxx:1139
 AliFlowTrackCuts.cxx:1140
 AliFlowTrackCuts.cxx:1141
 AliFlowTrackCuts.cxx:1142
 AliFlowTrackCuts.cxx:1143
 AliFlowTrackCuts.cxx:1144
 AliFlowTrackCuts.cxx:1145
 AliFlowTrackCuts.cxx:1146
 AliFlowTrackCuts.cxx:1147
 AliFlowTrackCuts.cxx:1148
 AliFlowTrackCuts.cxx:1149
 AliFlowTrackCuts.cxx:1150
 AliFlowTrackCuts.cxx:1151
 AliFlowTrackCuts.cxx:1152
 AliFlowTrackCuts.cxx:1153
 AliFlowTrackCuts.cxx:1154
 AliFlowTrackCuts.cxx:1155
 AliFlowTrackCuts.cxx:1156
 AliFlowTrackCuts.cxx:1157
 AliFlowTrackCuts.cxx:1158
 AliFlowTrackCuts.cxx:1159
 AliFlowTrackCuts.cxx:1160
 AliFlowTrackCuts.cxx:1161
 AliFlowTrackCuts.cxx:1162
 AliFlowTrackCuts.cxx:1163
 AliFlowTrackCuts.cxx:1164
 AliFlowTrackCuts.cxx:1165
 AliFlowTrackCuts.cxx:1166
 AliFlowTrackCuts.cxx:1167
 AliFlowTrackCuts.cxx:1168
 AliFlowTrackCuts.cxx:1169
 AliFlowTrackCuts.cxx:1170
 AliFlowTrackCuts.cxx:1171
 AliFlowTrackCuts.cxx:1172
 AliFlowTrackCuts.cxx:1173
 AliFlowTrackCuts.cxx:1174
 AliFlowTrackCuts.cxx:1175
 AliFlowTrackCuts.cxx:1176
 AliFlowTrackCuts.cxx:1177
 AliFlowTrackCuts.cxx:1178
 AliFlowTrackCuts.cxx:1179
 AliFlowTrackCuts.cxx:1180
 AliFlowTrackCuts.cxx:1181
 AliFlowTrackCuts.cxx:1182
 AliFlowTrackCuts.cxx:1183
 AliFlowTrackCuts.cxx:1184
 AliFlowTrackCuts.cxx:1185
 AliFlowTrackCuts.cxx:1186
 AliFlowTrackCuts.cxx:1187
 AliFlowTrackCuts.cxx:1188
 AliFlowTrackCuts.cxx:1189
 AliFlowTrackCuts.cxx:1190
 AliFlowTrackCuts.cxx:1191
 AliFlowTrackCuts.cxx:1192
 AliFlowTrackCuts.cxx:1193
 AliFlowTrackCuts.cxx:1194
 AliFlowTrackCuts.cxx:1195
 AliFlowTrackCuts.cxx:1196
 AliFlowTrackCuts.cxx:1197
 AliFlowTrackCuts.cxx:1198
 AliFlowTrackCuts.cxx:1199
 AliFlowTrackCuts.cxx:1200
 AliFlowTrackCuts.cxx:1201
 AliFlowTrackCuts.cxx:1202
 AliFlowTrackCuts.cxx:1203
 AliFlowTrackCuts.cxx:1204
 AliFlowTrackCuts.cxx:1205
 AliFlowTrackCuts.cxx:1206
 AliFlowTrackCuts.cxx:1207
 AliFlowTrackCuts.cxx:1208
 AliFlowTrackCuts.cxx:1209
 AliFlowTrackCuts.cxx:1210
 AliFlowTrackCuts.cxx:1211
 AliFlowTrackCuts.cxx:1212
 AliFlowTrackCuts.cxx:1213
 AliFlowTrackCuts.cxx:1214
 AliFlowTrackCuts.cxx:1215
 AliFlowTrackCuts.cxx:1216
 AliFlowTrackCuts.cxx:1217
 AliFlowTrackCuts.cxx:1218
 AliFlowTrackCuts.cxx:1219
 AliFlowTrackCuts.cxx:1220
 AliFlowTrackCuts.cxx:1221
 AliFlowTrackCuts.cxx:1222
 AliFlowTrackCuts.cxx:1223
 AliFlowTrackCuts.cxx:1224
 AliFlowTrackCuts.cxx:1225
 AliFlowTrackCuts.cxx:1226
 AliFlowTrackCuts.cxx:1227
 AliFlowTrackCuts.cxx:1228
 AliFlowTrackCuts.cxx:1229
 AliFlowTrackCuts.cxx:1230
 AliFlowTrackCuts.cxx:1231
 AliFlowTrackCuts.cxx:1232
 AliFlowTrackCuts.cxx:1233
 AliFlowTrackCuts.cxx:1234
 AliFlowTrackCuts.cxx:1235
 AliFlowTrackCuts.cxx:1236
 AliFlowTrackCuts.cxx:1237
 AliFlowTrackCuts.cxx:1238
 AliFlowTrackCuts.cxx:1239
 AliFlowTrackCuts.cxx:1240
 AliFlowTrackCuts.cxx:1241
 AliFlowTrackCuts.cxx:1242
 AliFlowTrackCuts.cxx:1243
 AliFlowTrackCuts.cxx:1244
 AliFlowTrackCuts.cxx:1245
 AliFlowTrackCuts.cxx:1246
 AliFlowTrackCuts.cxx:1247
 AliFlowTrackCuts.cxx:1248
 AliFlowTrackCuts.cxx:1249
 AliFlowTrackCuts.cxx:1250
 AliFlowTrackCuts.cxx:1251
 AliFlowTrackCuts.cxx:1252
 AliFlowTrackCuts.cxx:1253
 AliFlowTrackCuts.cxx:1254
 AliFlowTrackCuts.cxx:1255
 AliFlowTrackCuts.cxx:1256
 AliFlowTrackCuts.cxx:1257
 AliFlowTrackCuts.cxx:1258
 AliFlowTrackCuts.cxx:1259
 AliFlowTrackCuts.cxx:1260
 AliFlowTrackCuts.cxx:1261
 AliFlowTrackCuts.cxx:1262
 AliFlowTrackCuts.cxx:1263
 AliFlowTrackCuts.cxx:1264
 AliFlowTrackCuts.cxx:1265
 AliFlowTrackCuts.cxx:1266
 AliFlowTrackCuts.cxx:1267
 AliFlowTrackCuts.cxx:1268
 AliFlowTrackCuts.cxx:1269
 AliFlowTrackCuts.cxx:1270
 AliFlowTrackCuts.cxx:1271
 AliFlowTrackCuts.cxx:1272
 AliFlowTrackCuts.cxx:1273
 AliFlowTrackCuts.cxx:1274
 AliFlowTrackCuts.cxx:1275
 AliFlowTrackCuts.cxx:1276
 AliFlowTrackCuts.cxx:1277
 AliFlowTrackCuts.cxx:1278
 AliFlowTrackCuts.cxx:1279
 AliFlowTrackCuts.cxx:1280
 AliFlowTrackCuts.cxx:1281
 AliFlowTrackCuts.cxx:1282
 AliFlowTrackCuts.cxx:1283
 AliFlowTrackCuts.cxx:1284
 AliFlowTrackCuts.cxx:1285
 AliFlowTrackCuts.cxx:1286
 AliFlowTrackCuts.cxx:1287
 AliFlowTrackCuts.cxx:1288
 AliFlowTrackCuts.cxx:1289
 AliFlowTrackCuts.cxx:1290
 AliFlowTrackCuts.cxx:1291
 AliFlowTrackCuts.cxx:1292
 AliFlowTrackCuts.cxx:1293
 AliFlowTrackCuts.cxx:1294
 AliFlowTrackCuts.cxx:1295
 AliFlowTrackCuts.cxx:1296
 AliFlowTrackCuts.cxx:1297
 AliFlowTrackCuts.cxx:1298
 AliFlowTrackCuts.cxx:1299
 AliFlowTrackCuts.cxx:1300
 AliFlowTrackCuts.cxx:1301
 AliFlowTrackCuts.cxx:1302
 AliFlowTrackCuts.cxx:1303
 AliFlowTrackCuts.cxx:1304
 AliFlowTrackCuts.cxx:1305
 AliFlowTrackCuts.cxx:1306
 AliFlowTrackCuts.cxx:1307
 AliFlowTrackCuts.cxx:1308
 AliFlowTrackCuts.cxx:1309
 AliFlowTrackCuts.cxx:1310
 AliFlowTrackCuts.cxx:1311
 AliFlowTrackCuts.cxx:1312
 AliFlowTrackCuts.cxx:1313
 AliFlowTrackCuts.cxx:1314
 AliFlowTrackCuts.cxx:1315
 AliFlowTrackCuts.cxx:1316
 AliFlowTrackCuts.cxx:1317
 AliFlowTrackCuts.cxx:1318
 AliFlowTrackCuts.cxx:1319
 AliFlowTrackCuts.cxx:1320
 AliFlowTrackCuts.cxx:1321
 AliFlowTrackCuts.cxx:1322
 AliFlowTrackCuts.cxx:1323
 AliFlowTrackCuts.cxx:1324
 AliFlowTrackCuts.cxx:1325
 AliFlowTrackCuts.cxx:1326
 AliFlowTrackCuts.cxx:1327
 AliFlowTrackCuts.cxx:1328
 AliFlowTrackCuts.cxx:1329
 AliFlowTrackCuts.cxx:1330
 AliFlowTrackCuts.cxx:1331
 AliFlowTrackCuts.cxx:1332
 AliFlowTrackCuts.cxx:1333
 AliFlowTrackCuts.cxx:1334
 AliFlowTrackCuts.cxx:1335
 AliFlowTrackCuts.cxx:1336
 AliFlowTrackCuts.cxx:1337
 AliFlowTrackCuts.cxx:1338
 AliFlowTrackCuts.cxx:1339
 AliFlowTrackCuts.cxx:1340
 AliFlowTrackCuts.cxx:1341
 AliFlowTrackCuts.cxx:1342
 AliFlowTrackCuts.cxx:1343
 AliFlowTrackCuts.cxx:1344
 AliFlowTrackCuts.cxx:1345
 AliFlowTrackCuts.cxx:1346
 AliFlowTrackCuts.cxx:1347
 AliFlowTrackCuts.cxx:1348
 AliFlowTrackCuts.cxx:1349
 AliFlowTrackCuts.cxx:1350
 AliFlowTrackCuts.cxx:1351
 AliFlowTrackCuts.cxx:1352
 AliFlowTrackCuts.cxx:1353
 AliFlowTrackCuts.cxx:1354
 AliFlowTrackCuts.cxx:1355
 AliFlowTrackCuts.cxx:1356
 AliFlowTrackCuts.cxx:1357
 AliFlowTrackCuts.cxx:1358
 AliFlowTrackCuts.cxx:1359
 AliFlowTrackCuts.cxx:1360
 AliFlowTrackCuts.cxx:1361
 AliFlowTrackCuts.cxx:1362
 AliFlowTrackCuts.cxx:1363
 AliFlowTrackCuts.cxx:1364
 AliFlowTrackCuts.cxx:1365
 AliFlowTrackCuts.cxx:1366
 AliFlowTrackCuts.cxx:1367
 AliFlowTrackCuts.cxx:1368
 AliFlowTrackCuts.cxx:1369
 AliFlowTrackCuts.cxx:1370
 AliFlowTrackCuts.cxx:1371
 AliFlowTrackCuts.cxx:1372
 AliFlowTrackCuts.cxx:1373
 AliFlowTrackCuts.cxx:1374
 AliFlowTrackCuts.cxx:1375
 AliFlowTrackCuts.cxx:1376
 AliFlowTrackCuts.cxx:1377
 AliFlowTrackCuts.cxx:1378
 AliFlowTrackCuts.cxx:1379
 AliFlowTrackCuts.cxx:1380
 AliFlowTrackCuts.cxx:1381
 AliFlowTrackCuts.cxx:1382
 AliFlowTrackCuts.cxx:1383
 AliFlowTrackCuts.cxx:1384
 AliFlowTrackCuts.cxx:1385
 AliFlowTrackCuts.cxx:1386
 AliFlowTrackCuts.cxx:1387
 AliFlowTrackCuts.cxx:1388
 AliFlowTrackCuts.cxx:1389
 AliFlowTrackCuts.cxx:1390
 AliFlowTrackCuts.cxx:1391
 AliFlowTrackCuts.cxx:1392
 AliFlowTrackCuts.cxx:1393
 AliFlowTrackCuts.cxx:1394
 AliFlowTrackCuts.cxx:1395
 AliFlowTrackCuts.cxx:1396
 AliFlowTrackCuts.cxx:1397
 AliFlowTrackCuts.cxx:1398
 AliFlowTrackCuts.cxx:1399
 AliFlowTrackCuts.cxx:1400
 AliFlowTrackCuts.cxx:1401
 AliFlowTrackCuts.cxx:1402
 AliFlowTrackCuts.cxx:1403
 AliFlowTrackCuts.cxx:1404
 AliFlowTrackCuts.cxx:1405
 AliFlowTrackCuts.cxx:1406
 AliFlowTrackCuts.cxx:1407
 AliFlowTrackCuts.cxx:1408
 AliFlowTrackCuts.cxx:1409
 AliFlowTrackCuts.cxx:1410
 AliFlowTrackCuts.cxx:1411
 AliFlowTrackCuts.cxx:1412
 AliFlowTrackCuts.cxx:1413
 AliFlowTrackCuts.cxx:1414
 AliFlowTrackCuts.cxx:1415
 AliFlowTrackCuts.cxx:1416
 AliFlowTrackCuts.cxx:1417
 AliFlowTrackCuts.cxx:1418
 AliFlowTrackCuts.cxx:1419
 AliFlowTrackCuts.cxx:1420
 AliFlowTrackCuts.cxx:1421
 AliFlowTrackCuts.cxx:1422
 AliFlowTrackCuts.cxx:1423
 AliFlowTrackCuts.cxx:1424
 AliFlowTrackCuts.cxx:1425
 AliFlowTrackCuts.cxx:1426
 AliFlowTrackCuts.cxx:1427
 AliFlowTrackCuts.cxx:1428
 AliFlowTrackCuts.cxx:1429
 AliFlowTrackCuts.cxx:1430
 AliFlowTrackCuts.cxx:1431
 AliFlowTrackCuts.cxx:1432
 AliFlowTrackCuts.cxx:1433
 AliFlowTrackCuts.cxx:1434
 AliFlowTrackCuts.cxx:1435
 AliFlowTrackCuts.cxx:1436
 AliFlowTrackCuts.cxx:1437
 AliFlowTrackCuts.cxx:1438
 AliFlowTrackCuts.cxx:1439
 AliFlowTrackCuts.cxx:1440
 AliFlowTrackCuts.cxx:1441
 AliFlowTrackCuts.cxx:1442
 AliFlowTrackCuts.cxx:1443
 AliFlowTrackCuts.cxx:1444
 AliFlowTrackCuts.cxx:1445
 AliFlowTrackCuts.cxx:1446
 AliFlowTrackCuts.cxx:1447
 AliFlowTrackCuts.cxx:1448
 AliFlowTrackCuts.cxx:1449
 AliFlowTrackCuts.cxx:1450
 AliFlowTrackCuts.cxx:1451
 AliFlowTrackCuts.cxx:1452
 AliFlowTrackCuts.cxx:1453
 AliFlowTrackCuts.cxx:1454
 AliFlowTrackCuts.cxx:1455
 AliFlowTrackCuts.cxx:1456
 AliFlowTrackCuts.cxx:1457
 AliFlowTrackCuts.cxx:1458
 AliFlowTrackCuts.cxx:1459
 AliFlowTrackCuts.cxx:1460
 AliFlowTrackCuts.cxx:1461
 AliFlowTrackCuts.cxx:1462
 AliFlowTrackCuts.cxx:1463
 AliFlowTrackCuts.cxx:1464
 AliFlowTrackCuts.cxx:1465
 AliFlowTrackCuts.cxx:1466
 AliFlowTrackCuts.cxx:1467
 AliFlowTrackCuts.cxx:1468
 AliFlowTrackCuts.cxx:1469
 AliFlowTrackCuts.cxx:1470
 AliFlowTrackCuts.cxx:1471
 AliFlowTrackCuts.cxx:1472
 AliFlowTrackCuts.cxx:1473
 AliFlowTrackCuts.cxx:1474
 AliFlowTrackCuts.cxx:1475
 AliFlowTrackCuts.cxx:1476
 AliFlowTrackCuts.cxx:1477
 AliFlowTrackCuts.cxx:1478
 AliFlowTrackCuts.cxx:1479
 AliFlowTrackCuts.cxx:1480
 AliFlowTrackCuts.cxx:1481
 AliFlowTrackCuts.cxx:1482
 AliFlowTrackCuts.cxx:1483
 AliFlowTrackCuts.cxx:1484
 AliFlowTrackCuts.cxx:1485
 AliFlowTrackCuts.cxx:1486
 AliFlowTrackCuts.cxx:1487
 AliFlowTrackCuts.cxx:1488
 AliFlowTrackCuts.cxx:1489
 AliFlowTrackCuts.cxx:1490
 AliFlowTrackCuts.cxx:1491
 AliFlowTrackCuts.cxx:1492
 AliFlowTrackCuts.cxx:1493
 AliFlowTrackCuts.cxx:1494
 AliFlowTrackCuts.cxx:1495
 AliFlowTrackCuts.cxx:1496
 AliFlowTrackCuts.cxx:1497
 AliFlowTrackCuts.cxx:1498
 AliFlowTrackCuts.cxx:1499
 AliFlowTrackCuts.cxx:1500
 AliFlowTrackCuts.cxx:1501
 AliFlowTrackCuts.cxx:1502
 AliFlowTrackCuts.cxx:1503
 AliFlowTrackCuts.cxx:1504
 AliFlowTrackCuts.cxx:1505
 AliFlowTrackCuts.cxx:1506
 AliFlowTrackCuts.cxx:1507
 AliFlowTrackCuts.cxx:1508
 AliFlowTrackCuts.cxx:1509
 AliFlowTrackCuts.cxx:1510
 AliFlowTrackCuts.cxx:1511
 AliFlowTrackCuts.cxx:1512
 AliFlowTrackCuts.cxx:1513
 AliFlowTrackCuts.cxx:1514
 AliFlowTrackCuts.cxx:1515
 AliFlowTrackCuts.cxx:1516
 AliFlowTrackCuts.cxx:1517
 AliFlowTrackCuts.cxx:1518
 AliFlowTrackCuts.cxx:1519
 AliFlowTrackCuts.cxx:1520
 AliFlowTrackCuts.cxx:1521
 AliFlowTrackCuts.cxx:1522
 AliFlowTrackCuts.cxx:1523
 AliFlowTrackCuts.cxx:1524
 AliFlowTrackCuts.cxx:1525
 AliFlowTrackCuts.cxx:1526
 AliFlowTrackCuts.cxx:1527
 AliFlowTrackCuts.cxx:1528
 AliFlowTrackCuts.cxx:1529
 AliFlowTrackCuts.cxx:1530
 AliFlowTrackCuts.cxx:1531
 AliFlowTrackCuts.cxx:1532
 AliFlowTrackCuts.cxx:1533
 AliFlowTrackCuts.cxx:1534
 AliFlowTrackCuts.cxx:1535
 AliFlowTrackCuts.cxx:1536
 AliFlowTrackCuts.cxx:1537
 AliFlowTrackCuts.cxx:1538
 AliFlowTrackCuts.cxx:1539
 AliFlowTrackCuts.cxx:1540
 AliFlowTrackCuts.cxx:1541
 AliFlowTrackCuts.cxx:1542
 AliFlowTrackCuts.cxx:1543
 AliFlowTrackCuts.cxx:1544
 AliFlowTrackCuts.cxx:1545
 AliFlowTrackCuts.cxx:1546
 AliFlowTrackCuts.cxx:1547
 AliFlowTrackCuts.cxx:1548
 AliFlowTrackCuts.cxx:1549
 AliFlowTrackCuts.cxx:1550
 AliFlowTrackCuts.cxx:1551
 AliFlowTrackCuts.cxx:1552
 AliFlowTrackCuts.cxx:1553
 AliFlowTrackCuts.cxx:1554
 AliFlowTrackCuts.cxx:1555
 AliFlowTrackCuts.cxx:1556
 AliFlowTrackCuts.cxx:1557
 AliFlowTrackCuts.cxx:1558
 AliFlowTrackCuts.cxx:1559
 AliFlowTrackCuts.cxx:1560
 AliFlowTrackCuts.cxx:1561
 AliFlowTrackCuts.cxx:1562
 AliFlowTrackCuts.cxx:1563
 AliFlowTrackCuts.cxx:1564
 AliFlowTrackCuts.cxx:1565
 AliFlowTrackCuts.cxx:1566
 AliFlowTrackCuts.cxx:1567
 AliFlowTrackCuts.cxx:1568
 AliFlowTrackCuts.cxx:1569
 AliFlowTrackCuts.cxx:1570
 AliFlowTrackCuts.cxx:1571
 AliFlowTrackCuts.cxx:1572
 AliFlowTrackCuts.cxx:1573
 AliFlowTrackCuts.cxx:1574
 AliFlowTrackCuts.cxx:1575
 AliFlowTrackCuts.cxx:1576
 AliFlowTrackCuts.cxx:1577
 AliFlowTrackCuts.cxx:1578
 AliFlowTrackCuts.cxx:1579
 AliFlowTrackCuts.cxx:1580
 AliFlowTrackCuts.cxx:1581
 AliFlowTrackCuts.cxx:1582
 AliFlowTrackCuts.cxx:1583
 AliFlowTrackCuts.cxx:1584
 AliFlowTrackCuts.cxx:1585
 AliFlowTrackCuts.cxx:1586
 AliFlowTrackCuts.cxx:1587
 AliFlowTrackCuts.cxx:1588
 AliFlowTrackCuts.cxx:1589
 AliFlowTrackCuts.cxx:1590
 AliFlowTrackCuts.cxx:1591
 AliFlowTrackCuts.cxx:1592
 AliFlowTrackCuts.cxx:1593
 AliFlowTrackCuts.cxx:1594
 AliFlowTrackCuts.cxx:1595
 AliFlowTrackCuts.cxx:1596
 AliFlowTrackCuts.cxx:1597
 AliFlowTrackCuts.cxx:1598
 AliFlowTrackCuts.cxx:1599
 AliFlowTrackCuts.cxx:1600
 AliFlowTrackCuts.cxx:1601
 AliFlowTrackCuts.cxx:1602
 AliFlowTrackCuts.cxx:1603
 AliFlowTrackCuts.cxx:1604
 AliFlowTrackCuts.cxx:1605
 AliFlowTrackCuts.cxx:1606
 AliFlowTrackCuts.cxx:1607
 AliFlowTrackCuts.cxx:1608
 AliFlowTrackCuts.cxx:1609
 AliFlowTrackCuts.cxx:1610
 AliFlowTrackCuts.cxx:1611
 AliFlowTrackCuts.cxx:1612
 AliFlowTrackCuts.cxx:1613
 AliFlowTrackCuts.cxx:1614
 AliFlowTrackCuts.cxx:1615
 AliFlowTrackCuts.cxx:1616
 AliFlowTrackCuts.cxx:1617
 AliFlowTrackCuts.cxx:1618
 AliFlowTrackCuts.cxx:1619
 AliFlowTrackCuts.cxx:1620
 AliFlowTrackCuts.cxx:1621
 AliFlowTrackCuts.cxx:1622
 AliFlowTrackCuts.cxx:1623
 AliFlowTrackCuts.cxx:1624
 AliFlowTrackCuts.cxx:1625
 AliFlowTrackCuts.cxx:1626
 AliFlowTrackCuts.cxx:1627
 AliFlowTrackCuts.cxx:1628
 AliFlowTrackCuts.cxx:1629
 AliFlowTrackCuts.cxx:1630
 AliFlowTrackCuts.cxx:1631
 AliFlowTrackCuts.cxx:1632
 AliFlowTrackCuts.cxx:1633
 AliFlowTrackCuts.cxx:1634
 AliFlowTrackCuts.cxx:1635
 AliFlowTrackCuts.cxx:1636
 AliFlowTrackCuts.cxx:1637
 AliFlowTrackCuts.cxx:1638
 AliFlowTrackCuts.cxx:1639
 AliFlowTrackCuts.cxx:1640
 AliFlowTrackCuts.cxx:1641
 AliFlowTrackCuts.cxx:1642
 AliFlowTrackCuts.cxx:1643
 AliFlowTrackCuts.cxx:1644
 AliFlowTrackCuts.cxx:1645
 AliFlowTrackCuts.cxx:1646
 AliFlowTrackCuts.cxx:1647
 AliFlowTrackCuts.cxx:1648
 AliFlowTrackCuts.cxx:1649
 AliFlowTrackCuts.cxx:1650
 AliFlowTrackCuts.cxx:1651
 AliFlowTrackCuts.cxx:1652
 AliFlowTrackCuts.cxx:1653
 AliFlowTrackCuts.cxx:1654
 AliFlowTrackCuts.cxx:1655
 AliFlowTrackCuts.cxx:1656
 AliFlowTrackCuts.cxx:1657
 AliFlowTrackCuts.cxx:1658
 AliFlowTrackCuts.cxx:1659
 AliFlowTrackCuts.cxx:1660
 AliFlowTrackCuts.cxx:1661
 AliFlowTrackCuts.cxx:1662
 AliFlowTrackCuts.cxx:1663
 AliFlowTrackCuts.cxx:1664
 AliFlowTrackCuts.cxx:1665
 AliFlowTrackCuts.cxx:1666
 AliFlowTrackCuts.cxx:1667
 AliFlowTrackCuts.cxx:1668
 AliFlowTrackCuts.cxx:1669
 AliFlowTrackCuts.cxx:1670
 AliFlowTrackCuts.cxx:1671
 AliFlowTrackCuts.cxx:1672
 AliFlowTrackCuts.cxx:1673
 AliFlowTrackCuts.cxx:1674
 AliFlowTrackCuts.cxx:1675
 AliFlowTrackCuts.cxx:1676
 AliFlowTrackCuts.cxx:1677
 AliFlowTrackCuts.cxx:1678
 AliFlowTrackCuts.cxx:1679
 AliFlowTrackCuts.cxx:1680
 AliFlowTrackCuts.cxx:1681
 AliFlowTrackCuts.cxx:1682
 AliFlowTrackCuts.cxx:1683
 AliFlowTrackCuts.cxx:1684
 AliFlowTrackCuts.cxx:1685
 AliFlowTrackCuts.cxx:1686
 AliFlowTrackCuts.cxx:1687
 AliFlowTrackCuts.cxx:1688
 AliFlowTrackCuts.cxx:1689
 AliFlowTrackCuts.cxx:1690
 AliFlowTrackCuts.cxx:1691
 AliFlowTrackCuts.cxx:1692
 AliFlowTrackCuts.cxx:1693
 AliFlowTrackCuts.cxx:1694
 AliFlowTrackCuts.cxx:1695
 AliFlowTrackCuts.cxx:1696
 AliFlowTrackCuts.cxx:1697
 AliFlowTrackCuts.cxx:1698
 AliFlowTrackCuts.cxx:1699
 AliFlowTrackCuts.cxx:1700
 AliFlowTrackCuts.cxx:1701
 AliFlowTrackCuts.cxx:1702
 AliFlowTrackCuts.cxx:1703
 AliFlowTrackCuts.cxx:1704
 AliFlowTrackCuts.cxx:1705
 AliFlowTrackCuts.cxx:1706
 AliFlowTrackCuts.cxx:1707
 AliFlowTrackCuts.cxx:1708
 AliFlowTrackCuts.cxx:1709
 AliFlowTrackCuts.cxx:1710
 AliFlowTrackCuts.cxx:1711
 AliFlowTrackCuts.cxx:1712
 AliFlowTrackCuts.cxx:1713
 AliFlowTrackCuts.cxx:1714
 AliFlowTrackCuts.cxx:1715
 AliFlowTrackCuts.cxx:1716
 AliFlowTrackCuts.cxx:1717
 AliFlowTrackCuts.cxx:1718
 AliFlowTrackCuts.cxx:1719
 AliFlowTrackCuts.cxx:1720
 AliFlowTrackCuts.cxx:1721
 AliFlowTrackCuts.cxx:1722
 AliFlowTrackCuts.cxx:1723
 AliFlowTrackCuts.cxx:1724
 AliFlowTrackCuts.cxx:1725
 AliFlowTrackCuts.cxx:1726
 AliFlowTrackCuts.cxx:1727
 AliFlowTrackCuts.cxx:1728
 AliFlowTrackCuts.cxx:1729
 AliFlowTrackCuts.cxx:1730
 AliFlowTrackCuts.cxx:1731
 AliFlowTrackCuts.cxx:1732
 AliFlowTrackCuts.cxx:1733
 AliFlowTrackCuts.cxx:1734
 AliFlowTrackCuts.cxx:1735
 AliFlowTrackCuts.cxx:1736
 AliFlowTrackCuts.cxx:1737
 AliFlowTrackCuts.cxx:1738
 AliFlowTrackCuts.cxx:1739
 AliFlowTrackCuts.cxx:1740
 AliFlowTrackCuts.cxx:1741
 AliFlowTrackCuts.cxx:1742
 AliFlowTrackCuts.cxx:1743
 AliFlowTrackCuts.cxx:1744
 AliFlowTrackCuts.cxx:1745
 AliFlowTrackCuts.cxx:1746
 AliFlowTrackCuts.cxx:1747
 AliFlowTrackCuts.cxx:1748
 AliFlowTrackCuts.cxx:1749
 AliFlowTrackCuts.cxx:1750
 AliFlowTrackCuts.cxx:1751
 AliFlowTrackCuts.cxx:1752
 AliFlowTrackCuts.cxx:1753
 AliFlowTrackCuts.cxx:1754
 AliFlowTrackCuts.cxx:1755
 AliFlowTrackCuts.cxx:1756
 AliFlowTrackCuts.cxx:1757
 AliFlowTrackCuts.cxx:1758
 AliFlowTrackCuts.cxx:1759
 AliFlowTrackCuts.cxx:1760
 AliFlowTrackCuts.cxx:1761
 AliFlowTrackCuts.cxx:1762
 AliFlowTrackCuts.cxx:1763
 AliFlowTrackCuts.cxx:1764
 AliFlowTrackCuts.cxx:1765
 AliFlowTrackCuts.cxx:1766
 AliFlowTrackCuts.cxx:1767
 AliFlowTrackCuts.cxx:1768
 AliFlowTrackCuts.cxx:1769
 AliFlowTrackCuts.cxx:1770
 AliFlowTrackCuts.cxx:1771
 AliFlowTrackCuts.cxx:1772
 AliFlowTrackCuts.cxx:1773
 AliFlowTrackCuts.cxx:1774
 AliFlowTrackCuts.cxx:1775
 AliFlowTrackCuts.cxx:1776
 AliFlowTrackCuts.cxx:1777
 AliFlowTrackCuts.cxx:1778
 AliFlowTrackCuts.cxx:1779
 AliFlowTrackCuts.cxx:1780
 AliFlowTrackCuts.cxx:1781
 AliFlowTrackCuts.cxx:1782
 AliFlowTrackCuts.cxx:1783
 AliFlowTrackCuts.cxx:1784
 AliFlowTrackCuts.cxx:1785
 AliFlowTrackCuts.cxx:1786
 AliFlowTrackCuts.cxx:1787
 AliFlowTrackCuts.cxx:1788
 AliFlowTrackCuts.cxx:1789
 AliFlowTrackCuts.cxx:1790
 AliFlowTrackCuts.cxx:1791
 AliFlowTrackCuts.cxx:1792
 AliFlowTrackCuts.cxx:1793
 AliFlowTrackCuts.cxx:1794
 AliFlowTrackCuts.cxx:1795
 AliFlowTrackCuts.cxx:1796
 AliFlowTrackCuts.cxx:1797
 AliFlowTrackCuts.cxx:1798
 AliFlowTrackCuts.cxx:1799
 AliFlowTrackCuts.cxx:1800
 AliFlowTrackCuts.cxx:1801
 AliFlowTrackCuts.cxx:1802
 AliFlowTrackCuts.cxx:1803
 AliFlowTrackCuts.cxx:1804
 AliFlowTrackCuts.cxx:1805
 AliFlowTrackCuts.cxx:1806
 AliFlowTrackCuts.cxx:1807
 AliFlowTrackCuts.cxx:1808
 AliFlowTrackCuts.cxx:1809
 AliFlowTrackCuts.cxx:1810
 AliFlowTrackCuts.cxx:1811
 AliFlowTrackCuts.cxx:1812
 AliFlowTrackCuts.cxx:1813
 AliFlowTrackCuts.cxx:1814
 AliFlowTrackCuts.cxx:1815
 AliFlowTrackCuts.cxx:1816
 AliFlowTrackCuts.cxx:1817
 AliFlowTrackCuts.cxx:1818
 AliFlowTrackCuts.cxx:1819
 AliFlowTrackCuts.cxx:1820
 AliFlowTrackCuts.cxx:1821
 AliFlowTrackCuts.cxx:1822
 AliFlowTrackCuts.cxx:1823
 AliFlowTrackCuts.cxx:1824
 AliFlowTrackCuts.cxx:1825
 AliFlowTrackCuts.cxx:1826
 AliFlowTrackCuts.cxx:1827
 AliFlowTrackCuts.cxx:1828
 AliFlowTrackCuts.cxx:1829
 AliFlowTrackCuts.cxx:1830
 AliFlowTrackCuts.cxx:1831
 AliFlowTrackCuts.cxx:1832
 AliFlowTrackCuts.cxx:1833
 AliFlowTrackCuts.cxx:1834
 AliFlowTrackCuts.cxx:1835
 AliFlowTrackCuts.cxx:1836
 AliFlowTrackCuts.cxx:1837
 AliFlowTrackCuts.cxx:1838
 AliFlowTrackCuts.cxx:1839
 AliFlowTrackCuts.cxx:1840
 AliFlowTrackCuts.cxx:1841
 AliFlowTrackCuts.cxx:1842
 AliFlowTrackCuts.cxx:1843
 AliFlowTrackCuts.cxx:1844
 AliFlowTrackCuts.cxx:1845
 AliFlowTrackCuts.cxx:1846
 AliFlowTrackCuts.cxx:1847
 AliFlowTrackCuts.cxx:1848
 AliFlowTrackCuts.cxx:1849
 AliFlowTrackCuts.cxx:1850
 AliFlowTrackCuts.cxx:1851
 AliFlowTrackCuts.cxx:1852
 AliFlowTrackCuts.cxx:1853
 AliFlowTrackCuts.cxx:1854
 AliFlowTrackCuts.cxx:1855
 AliFlowTrackCuts.cxx:1856
 AliFlowTrackCuts.cxx:1857
 AliFlowTrackCuts.cxx:1858
 AliFlowTrackCuts.cxx:1859
 AliFlowTrackCuts.cxx:1860
 AliFlowTrackCuts.cxx:1861
 AliFlowTrackCuts.cxx:1862
 AliFlowTrackCuts.cxx:1863
 AliFlowTrackCuts.cxx:1864
 AliFlowTrackCuts.cxx:1865
 AliFlowTrackCuts.cxx:1866
 AliFlowTrackCuts.cxx:1867
 AliFlowTrackCuts.cxx:1868
 AliFlowTrackCuts.cxx:1869
 AliFlowTrackCuts.cxx:1870
 AliFlowTrackCuts.cxx:1871
 AliFlowTrackCuts.cxx:1872
 AliFlowTrackCuts.cxx:1873
 AliFlowTrackCuts.cxx:1874
 AliFlowTrackCuts.cxx:1875
 AliFlowTrackCuts.cxx:1876
 AliFlowTrackCuts.cxx:1877
 AliFlowTrackCuts.cxx:1878
 AliFlowTrackCuts.cxx:1879
 AliFlowTrackCuts.cxx:1880
 AliFlowTrackCuts.cxx:1881
 AliFlowTrackCuts.cxx:1882
 AliFlowTrackCuts.cxx:1883
 AliFlowTrackCuts.cxx:1884
 AliFlowTrackCuts.cxx:1885
 AliFlowTrackCuts.cxx:1886
 AliFlowTrackCuts.cxx:1887
 AliFlowTrackCuts.cxx:1888
 AliFlowTrackCuts.cxx:1889
 AliFlowTrackCuts.cxx:1890
 AliFlowTrackCuts.cxx:1891
 AliFlowTrackCuts.cxx:1892
 AliFlowTrackCuts.cxx:1893
 AliFlowTrackCuts.cxx:1894
 AliFlowTrackCuts.cxx:1895
 AliFlowTrackCuts.cxx:1896
 AliFlowTrackCuts.cxx:1897
 AliFlowTrackCuts.cxx:1898
 AliFlowTrackCuts.cxx:1899
 AliFlowTrackCuts.cxx:1900
 AliFlowTrackCuts.cxx:1901
 AliFlowTrackCuts.cxx:1902
 AliFlowTrackCuts.cxx:1903
 AliFlowTrackCuts.cxx:1904
 AliFlowTrackCuts.cxx:1905
 AliFlowTrackCuts.cxx:1906
 AliFlowTrackCuts.cxx:1907
 AliFlowTrackCuts.cxx:1908
 AliFlowTrackCuts.cxx:1909
 AliFlowTrackCuts.cxx:1910
 AliFlowTrackCuts.cxx:1911
 AliFlowTrackCuts.cxx:1912
 AliFlowTrackCuts.cxx:1913
 AliFlowTrackCuts.cxx:1914
 AliFlowTrackCuts.cxx:1915
 AliFlowTrackCuts.cxx:1916
 AliFlowTrackCuts.cxx:1917
 AliFlowTrackCuts.cxx:1918
 AliFlowTrackCuts.cxx:1919
 AliFlowTrackCuts.cxx:1920
 AliFlowTrackCuts.cxx:1921
 AliFlowTrackCuts.cxx:1922
 AliFlowTrackCuts.cxx:1923
 AliFlowTrackCuts.cxx:1924
 AliFlowTrackCuts.cxx:1925
 AliFlowTrackCuts.cxx:1926
 AliFlowTrackCuts.cxx:1927
 AliFlowTrackCuts.cxx:1928
 AliFlowTrackCuts.cxx:1929
 AliFlowTrackCuts.cxx:1930
 AliFlowTrackCuts.cxx:1931
 AliFlowTrackCuts.cxx:1932
 AliFlowTrackCuts.cxx:1933
 AliFlowTrackCuts.cxx:1934
 AliFlowTrackCuts.cxx:1935
 AliFlowTrackCuts.cxx:1936
 AliFlowTrackCuts.cxx:1937
 AliFlowTrackCuts.cxx:1938
 AliFlowTrackCuts.cxx:1939
 AliFlowTrackCuts.cxx:1940
 AliFlowTrackCuts.cxx:1941
 AliFlowTrackCuts.cxx:1942
 AliFlowTrackCuts.cxx:1943
 AliFlowTrackCuts.cxx:1944
 AliFlowTrackCuts.cxx:1945
 AliFlowTrackCuts.cxx:1946
 AliFlowTrackCuts.cxx:1947
 AliFlowTrackCuts.cxx:1948
 AliFlowTrackCuts.cxx:1949
 AliFlowTrackCuts.cxx:1950
 AliFlowTrackCuts.cxx:1951
 AliFlowTrackCuts.cxx:1952
 AliFlowTrackCuts.cxx:1953
 AliFlowTrackCuts.cxx:1954
 AliFlowTrackCuts.cxx:1955
 AliFlowTrackCuts.cxx:1956
 AliFlowTrackCuts.cxx:1957
 AliFlowTrackCuts.cxx:1958
 AliFlowTrackCuts.cxx:1959
 AliFlowTrackCuts.cxx:1960
 AliFlowTrackCuts.cxx:1961
 AliFlowTrackCuts.cxx:1962
 AliFlowTrackCuts.cxx:1963
 AliFlowTrackCuts.cxx:1964
 AliFlowTrackCuts.cxx:1965
 AliFlowTrackCuts.cxx:1966
 AliFlowTrackCuts.cxx:1967
 AliFlowTrackCuts.cxx:1968
 AliFlowTrackCuts.cxx:1969
 AliFlowTrackCuts.cxx:1970
 AliFlowTrackCuts.cxx:1971
 AliFlowTrackCuts.cxx:1972
 AliFlowTrackCuts.cxx:1973
 AliFlowTrackCuts.cxx:1974
 AliFlowTrackCuts.cxx:1975
 AliFlowTrackCuts.cxx:1976
 AliFlowTrackCuts.cxx:1977
 AliFlowTrackCuts.cxx:1978
 AliFlowTrackCuts.cxx:1979
 AliFlowTrackCuts.cxx:1980
 AliFlowTrackCuts.cxx:1981
 AliFlowTrackCuts.cxx:1982
 AliFlowTrackCuts.cxx:1983
 AliFlowTrackCuts.cxx:1984
 AliFlowTrackCuts.cxx:1985
 AliFlowTrackCuts.cxx:1986
 AliFlowTrackCuts.cxx:1987
 AliFlowTrackCuts.cxx:1988
 AliFlowTrackCuts.cxx:1989
 AliFlowTrackCuts.cxx:1990
 AliFlowTrackCuts.cxx:1991
 AliFlowTrackCuts.cxx:1992
 AliFlowTrackCuts.cxx:1993
 AliFlowTrackCuts.cxx:1994
 AliFlowTrackCuts.cxx:1995
 AliFlowTrackCuts.cxx:1996
 AliFlowTrackCuts.cxx:1997
 AliFlowTrackCuts.cxx:1998
 AliFlowTrackCuts.cxx:1999
 AliFlowTrackCuts.cxx:2000
 AliFlowTrackCuts.cxx:2001
 AliFlowTrackCuts.cxx:2002
 AliFlowTrackCuts.cxx:2003
 AliFlowTrackCuts.cxx:2004
 AliFlowTrackCuts.cxx:2005
 AliFlowTrackCuts.cxx:2006
 AliFlowTrackCuts.cxx:2007
 AliFlowTrackCuts.cxx:2008
 AliFlowTrackCuts.cxx:2009
 AliFlowTrackCuts.cxx:2010
 AliFlowTrackCuts.cxx:2011
 AliFlowTrackCuts.cxx:2012
 AliFlowTrackCuts.cxx:2013
 AliFlowTrackCuts.cxx:2014
 AliFlowTrackCuts.cxx:2015
 AliFlowTrackCuts.cxx:2016
 AliFlowTrackCuts.cxx:2017
 AliFlowTrackCuts.cxx:2018
 AliFlowTrackCuts.cxx:2019
 AliFlowTrackCuts.cxx:2020
 AliFlowTrackCuts.cxx:2021
 AliFlowTrackCuts.cxx:2022
 AliFlowTrackCuts.cxx:2023
 AliFlowTrackCuts.cxx:2024
 AliFlowTrackCuts.cxx:2025
 AliFlowTrackCuts.cxx:2026
 AliFlowTrackCuts.cxx:2027
 AliFlowTrackCuts.cxx:2028
 AliFlowTrackCuts.cxx:2029
 AliFlowTrackCuts.cxx:2030
 AliFlowTrackCuts.cxx:2031
 AliFlowTrackCuts.cxx:2032
 AliFlowTrackCuts.cxx:2033
 AliFlowTrackCuts.cxx:2034
 AliFlowTrackCuts.cxx:2035
 AliFlowTrackCuts.cxx:2036
 AliFlowTrackCuts.cxx:2037
 AliFlowTrackCuts.cxx:2038
 AliFlowTrackCuts.cxx:2039
 AliFlowTrackCuts.cxx:2040
 AliFlowTrackCuts.cxx:2041
 AliFlowTrackCuts.cxx:2042
 AliFlowTrackCuts.cxx:2043
 AliFlowTrackCuts.cxx:2044
 AliFlowTrackCuts.cxx:2045
 AliFlowTrackCuts.cxx:2046
 AliFlowTrackCuts.cxx:2047
 AliFlowTrackCuts.cxx:2048
 AliFlowTrackCuts.cxx:2049
 AliFlowTrackCuts.cxx:2050
 AliFlowTrackCuts.cxx:2051
 AliFlowTrackCuts.cxx:2052
 AliFlowTrackCuts.cxx:2053
 AliFlowTrackCuts.cxx:2054
 AliFlowTrackCuts.cxx:2055
 AliFlowTrackCuts.cxx:2056
 AliFlowTrackCuts.cxx:2057
 AliFlowTrackCuts.cxx:2058
 AliFlowTrackCuts.cxx:2059
 AliFlowTrackCuts.cxx:2060
 AliFlowTrackCuts.cxx:2061
 AliFlowTrackCuts.cxx:2062
 AliFlowTrackCuts.cxx:2063
 AliFlowTrackCuts.cxx:2064
 AliFlowTrackCuts.cxx:2065
 AliFlowTrackCuts.cxx:2066
 AliFlowTrackCuts.cxx:2067
 AliFlowTrackCuts.cxx:2068
 AliFlowTrackCuts.cxx:2069
 AliFlowTrackCuts.cxx:2070
 AliFlowTrackCuts.cxx:2071
 AliFlowTrackCuts.cxx:2072
 AliFlowTrackCuts.cxx:2073
 AliFlowTrackCuts.cxx:2074
 AliFlowTrackCuts.cxx:2075
 AliFlowTrackCuts.cxx:2076
 AliFlowTrackCuts.cxx:2077
 AliFlowTrackCuts.cxx:2078
 AliFlowTrackCuts.cxx:2079
 AliFlowTrackCuts.cxx:2080
 AliFlowTrackCuts.cxx:2081
 AliFlowTrackCuts.cxx:2082
 AliFlowTrackCuts.cxx:2083
 AliFlowTrackCuts.cxx:2084
 AliFlowTrackCuts.cxx:2085
 AliFlowTrackCuts.cxx:2086
 AliFlowTrackCuts.cxx:2087
 AliFlowTrackCuts.cxx:2088
 AliFlowTrackCuts.cxx:2089
 AliFlowTrackCuts.cxx:2090
 AliFlowTrackCuts.cxx:2091
 AliFlowTrackCuts.cxx:2092
 AliFlowTrackCuts.cxx:2093
 AliFlowTrackCuts.cxx:2094
 AliFlowTrackCuts.cxx:2095
 AliFlowTrackCuts.cxx:2096
 AliFlowTrackCuts.cxx:2097
 AliFlowTrackCuts.cxx:2098
 AliFlowTrackCuts.cxx:2099
 AliFlowTrackCuts.cxx:2100
 AliFlowTrackCuts.cxx:2101
 AliFlowTrackCuts.cxx:2102
 AliFlowTrackCuts.cxx:2103
 AliFlowTrackCuts.cxx:2104
 AliFlowTrackCuts.cxx:2105
 AliFlowTrackCuts.cxx:2106
 AliFlowTrackCuts.cxx:2107
 AliFlowTrackCuts.cxx:2108
 AliFlowTrackCuts.cxx:2109
 AliFlowTrackCuts.cxx:2110
 AliFlowTrackCuts.cxx:2111
 AliFlowTrackCuts.cxx:2112
 AliFlowTrackCuts.cxx:2113
 AliFlowTrackCuts.cxx:2114
 AliFlowTrackCuts.cxx:2115
 AliFlowTrackCuts.cxx:2116
 AliFlowTrackCuts.cxx:2117
 AliFlowTrackCuts.cxx:2118
 AliFlowTrackCuts.cxx:2119
 AliFlowTrackCuts.cxx:2120
 AliFlowTrackCuts.cxx:2121
 AliFlowTrackCuts.cxx:2122
 AliFlowTrackCuts.cxx:2123
 AliFlowTrackCuts.cxx:2124
 AliFlowTrackCuts.cxx:2125
 AliFlowTrackCuts.cxx:2126
 AliFlowTrackCuts.cxx:2127
 AliFlowTrackCuts.cxx:2128
 AliFlowTrackCuts.cxx:2129
 AliFlowTrackCuts.cxx:2130
 AliFlowTrackCuts.cxx:2131
 AliFlowTrackCuts.cxx:2132
 AliFlowTrackCuts.cxx:2133
 AliFlowTrackCuts.cxx:2134
 AliFlowTrackCuts.cxx:2135
 AliFlowTrackCuts.cxx:2136
 AliFlowTrackCuts.cxx:2137
 AliFlowTrackCuts.cxx:2138
 AliFlowTrackCuts.cxx:2139
 AliFlowTrackCuts.cxx:2140
 AliFlowTrackCuts.cxx:2141
 AliFlowTrackCuts.cxx:2142
 AliFlowTrackCuts.cxx:2143
 AliFlowTrackCuts.cxx:2144
 AliFlowTrackCuts.cxx:2145
 AliFlowTrackCuts.cxx:2146
 AliFlowTrackCuts.cxx:2147
 AliFlowTrackCuts.cxx:2148
 AliFlowTrackCuts.cxx:2149
 AliFlowTrackCuts.cxx:2150
 AliFlowTrackCuts.cxx:2151
 AliFlowTrackCuts.cxx:2152
 AliFlowTrackCuts.cxx:2153
 AliFlowTrackCuts.cxx:2154
 AliFlowTrackCuts.cxx:2155
 AliFlowTrackCuts.cxx:2156
 AliFlowTrackCuts.cxx:2157
 AliFlowTrackCuts.cxx:2158
 AliFlowTrackCuts.cxx:2159
 AliFlowTrackCuts.cxx:2160
 AliFlowTrackCuts.cxx:2161
 AliFlowTrackCuts.cxx:2162
 AliFlowTrackCuts.cxx:2163
 AliFlowTrackCuts.cxx:2164
 AliFlowTrackCuts.cxx:2165
 AliFlowTrackCuts.cxx:2166
 AliFlowTrackCuts.cxx:2167
 AliFlowTrackCuts.cxx:2168
 AliFlowTrackCuts.cxx:2169
 AliFlowTrackCuts.cxx:2170
 AliFlowTrackCuts.cxx:2171
 AliFlowTrackCuts.cxx:2172
 AliFlowTrackCuts.cxx:2173
 AliFlowTrackCuts.cxx:2174
 AliFlowTrackCuts.cxx:2175
 AliFlowTrackCuts.cxx:2176
 AliFlowTrackCuts.cxx:2177
 AliFlowTrackCuts.cxx:2178
 AliFlowTrackCuts.cxx:2179
 AliFlowTrackCuts.cxx:2180
 AliFlowTrackCuts.cxx:2181
 AliFlowTrackCuts.cxx:2182
 AliFlowTrackCuts.cxx:2183
 AliFlowTrackCuts.cxx:2184
 AliFlowTrackCuts.cxx:2185
 AliFlowTrackCuts.cxx:2186
 AliFlowTrackCuts.cxx:2187
 AliFlowTrackCuts.cxx:2188
 AliFlowTrackCuts.cxx:2189
 AliFlowTrackCuts.cxx:2190
 AliFlowTrackCuts.cxx:2191
 AliFlowTrackCuts.cxx:2192
 AliFlowTrackCuts.cxx:2193
 AliFlowTrackCuts.cxx:2194
 AliFlowTrackCuts.cxx:2195
 AliFlowTrackCuts.cxx:2196
 AliFlowTrackCuts.cxx:2197
 AliFlowTrackCuts.cxx:2198
 AliFlowTrackCuts.cxx:2199
 AliFlowTrackCuts.cxx:2200
 AliFlowTrackCuts.cxx:2201
 AliFlowTrackCuts.cxx:2202
 AliFlowTrackCuts.cxx:2203
 AliFlowTrackCuts.cxx:2204
 AliFlowTrackCuts.cxx:2205
 AliFlowTrackCuts.cxx:2206
 AliFlowTrackCuts.cxx:2207
 AliFlowTrackCuts.cxx:2208
 AliFlowTrackCuts.cxx:2209
 AliFlowTrackCuts.cxx:2210
 AliFlowTrackCuts.cxx:2211
 AliFlowTrackCuts.cxx:2212
 AliFlowTrackCuts.cxx:2213
 AliFlowTrackCuts.cxx:2214
 AliFlowTrackCuts.cxx:2215
 AliFlowTrackCuts.cxx:2216
 AliFlowTrackCuts.cxx:2217
 AliFlowTrackCuts.cxx:2218
 AliFlowTrackCuts.cxx:2219
 AliFlowTrackCuts.cxx:2220
 AliFlowTrackCuts.cxx:2221
 AliFlowTrackCuts.cxx:2222
 AliFlowTrackCuts.cxx:2223
 AliFlowTrackCuts.cxx:2224
 AliFlowTrackCuts.cxx:2225
 AliFlowTrackCuts.cxx:2226
 AliFlowTrackCuts.cxx:2227
 AliFlowTrackCuts.cxx:2228
 AliFlowTrackCuts.cxx:2229
 AliFlowTrackCuts.cxx:2230
 AliFlowTrackCuts.cxx:2231
 AliFlowTrackCuts.cxx:2232
 AliFlowTrackCuts.cxx:2233
 AliFlowTrackCuts.cxx:2234
 AliFlowTrackCuts.cxx:2235
 AliFlowTrackCuts.cxx:2236
 AliFlowTrackCuts.cxx:2237
 AliFlowTrackCuts.cxx:2238
 AliFlowTrackCuts.cxx:2239
 AliFlowTrackCuts.cxx:2240
 AliFlowTrackCuts.cxx:2241
 AliFlowTrackCuts.cxx:2242
 AliFlowTrackCuts.cxx:2243
 AliFlowTrackCuts.cxx:2244
 AliFlowTrackCuts.cxx:2245
 AliFlowTrackCuts.cxx:2246
 AliFlowTrackCuts.cxx:2247
 AliFlowTrackCuts.cxx:2248
 AliFlowTrackCuts.cxx:2249
 AliFlowTrackCuts.cxx:2250
 AliFlowTrackCuts.cxx:2251
 AliFlowTrackCuts.cxx:2252
 AliFlowTrackCuts.cxx:2253
 AliFlowTrackCuts.cxx:2254
 AliFlowTrackCuts.cxx:2255
 AliFlowTrackCuts.cxx:2256
 AliFlowTrackCuts.cxx:2257
 AliFlowTrackCuts.cxx:2258
 AliFlowTrackCuts.cxx:2259
 AliFlowTrackCuts.cxx:2260
 AliFlowTrackCuts.cxx:2261
 AliFlowTrackCuts.cxx:2262
 AliFlowTrackCuts.cxx:2263
 AliFlowTrackCuts.cxx:2264
 AliFlowTrackCuts.cxx:2265
 AliFlowTrackCuts.cxx:2266
 AliFlowTrackCuts.cxx:2267
 AliFlowTrackCuts.cxx:2268
 AliFlowTrackCuts.cxx:2269
 AliFlowTrackCuts.cxx:2270
 AliFlowTrackCuts.cxx:2271
 AliFlowTrackCuts.cxx:2272
 AliFlowTrackCuts.cxx:2273
 AliFlowTrackCuts.cxx:2274
 AliFlowTrackCuts.cxx:2275
 AliFlowTrackCuts.cxx:2276
 AliFlowTrackCuts.cxx:2277
 AliFlowTrackCuts.cxx:2278
 AliFlowTrackCuts.cxx:2279
 AliFlowTrackCuts.cxx:2280
 AliFlowTrackCuts.cxx:2281
 AliFlowTrackCuts.cxx:2282
 AliFlowTrackCuts.cxx:2283
 AliFlowTrackCuts.cxx:2284
 AliFlowTrackCuts.cxx:2285
 AliFlowTrackCuts.cxx:2286
 AliFlowTrackCuts.cxx:2287
 AliFlowTrackCuts.cxx:2288
 AliFlowTrackCuts.cxx:2289
 AliFlowTrackCuts.cxx:2290
 AliFlowTrackCuts.cxx:2291
 AliFlowTrackCuts.cxx:2292
 AliFlowTrackCuts.cxx:2293
 AliFlowTrackCuts.cxx:2294
 AliFlowTrackCuts.cxx:2295
 AliFlowTrackCuts.cxx:2296
 AliFlowTrackCuts.cxx:2297
 AliFlowTrackCuts.cxx:2298
 AliFlowTrackCuts.cxx:2299
 AliFlowTrackCuts.cxx:2300
 AliFlowTrackCuts.cxx:2301
 AliFlowTrackCuts.cxx:2302
 AliFlowTrackCuts.cxx:2303
 AliFlowTrackCuts.cxx:2304
 AliFlowTrackCuts.cxx:2305
 AliFlowTrackCuts.cxx:2306
 AliFlowTrackCuts.cxx:2307
 AliFlowTrackCuts.cxx:2308
 AliFlowTrackCuts.cxx:2309
 AliFlowTrackCuts.cxx:2310
 AliFlowTrackCuts.cxx:2311
 AliFlowTrackCuts.cxx:2312
 AliFlowTrackCuts.cxx:2313
 AliFlowTrackCuts.cxx:2314
 AliFlowTrackCuts.cxx:2315
 AliFlowTrackCuts.cxx:2316
 AliFlowTrackCuts.cxx:2317
 AliFlowTrackCuts.cxx:2318
 AliFlowTrackCuts.cxx:2319
 AliFlowTrackCuts.cxx:2320
 AliFlowTrackCuts.cxx:2321
 AliFlowTrackCuts.cxx:2322
 AliFlowTrackCuts.cxx:2323
 AliFlowTrackCuts.cxx:2324
 AliFlowTrackCuts.cxx:2325
 AliFlowTrackCuts.cxx:2326
 AliFlowTrackCuts.cxx:2327
 AliFlowTrackCuts.cxx:2328
 AliFlowTrackCuts.cxx:2329
 AliFlowTrackCuts.cxx:2330
 AliFlowTrackCuts.cxx:2331
 AliFlowTrackCuts.cxx:2332
 AliFlowTrackCuts.cxx:2333
 AliFlowTrackCuts.cxx:2334
 AliFlowTrackCuts.cxx:2335
 AliFlowTrackCuts.cxx:2336
 AliFlowTrackCuts.cxx:2337
 AliFlowTrackCuts.cxx:2338
 AliFlowTrackCuts.cxx:2339
 AliFlowTrackCuts.cxx:2340
 AliFlowTrackCuts.cxx:2341
 AliFlowTrackCuts.cxx:2342
 AliFlowTrackCuts.cxx:2343
 AliFlowTrackCuts.cxx:2344
 AliFlowTrackCuts.cxx:2345
 AliFlowTrackCuts.cxx:2346
 AliFlowTrackCuts.cxx:2347
 AliFlowTrackCuts.cxx:2348
 AliFlowTrackCuts.cxx:2349
 AliFlowTrackCuts.cxx:2350
 AliFlowTrackCuts.cxx:2351
 AliFlowTrackCuts.cxx:2352
 AliFlowTrackCuts.cxx:2353
 AliFlowTrackCuts.cxx:2354
 AliFlowTrackCuts.cxx:2355
 AliFlowTrackCuts.cxx:2356
 AliFlowTrackCuts.cxx:2357
 AliFlowTrackCuts.cxx:2358
 AliFlowTrackCuts.cxx:2359
 AliFlowTrackCuts.cxx:2360
 AliFlowTrackCuts.cxx:2361
 AliFlowTrackCuts.cxx:2362
 AliFlowTrackCuts.cxx:2363
 AliFlowTrackCuts.cxx:2364
 AliFlowTrackCuts.cxx:2365
 AliFlowTrackCuts.cxx:2366
 AliFlowTrackCuts.cxx:2367
 AliFlowTrackCuts.cxx:2368
 AliFlowTrackCuts.cxx:2369
 AliFlowTrackCuts.cxx:2370
 AliFlowTrackCuts.cxx:2371
 AliFlowTrackCuts.cxx:2372
 AliFlowTrackCuts.cxx:2373
 AliFlowTrackCuts.cxx:2374
 AliFlowTrackCuts.cxx:2375
 AliFlowTrackCuts.cxx:2376
 AliFlowTrackCuts.cxx:2377
 AliFlowTrackCuts.cxx:2378
 AliFlowTrackCuts.cxx:2379
 AliFlowTrackCuts.cxx:2380
 AliFlowTrackCuts.cxx:2381
 AliFlowTrackCuts.cxx:2382
 AliFlowTrackCuts.cxx:2383
 AliFlowTrackCuts.cxx:2384
 AliFlowTrackCuts.cxx:2385
 AliFlowTrackCuts.cxx:2386
 AliFlowTrackCuts.cxx:2387
 AliFlowTrackCuts.cxx:2388
 AliFlowTrackCuts.cxx:2389
 AliFlowTrackCuts.cxx:2390
 AliFlowTrackCuts.cxx:2391
 AliFlowTrackCuts.cxx:2392
 AliFlowTrackCuts.cxx:2393
 AliFlowTrackCuts.cxx:2394
 AliFlowTrackCuts.cxx:2395
 AliFlowTrackCuts.cxx:2396
 AliFlowTrackCuts.cxx:2397
 AliFlowTrackCuts.cxx:2398
 AliFlowTrackCuts.cxx:2399
 AliFlowTrackCuts.cxx:2400
 AliFlowTrackCuts.cxx:2401
 AliFlowTrackCuts.cxx:2402
 AliFlowTrackCuts.cxx:2403
 AliFlowTrackCuts.cxx:2404
 AliFlowTrackCuts.cxx:2405
 AliFlowTrackCuts.cxx:2406
 AliFlowTrackCuts.cxx:2407
 AliFlowTrackCuts.cxx:2408
 AliFlowTrackCuts.cxx:2409
 AliFlowTrackCuts.cxx:2410
 AliFlowTrackCuts.cxx:2411
 AliFlowTrackCuts.cxx:2412
 AliFlowTrackCuts.cxx:2413
 AliFlowTrackCuts.cxx:2414
 AliFlowTrackCuts.cxx:2415
 AliFlowTrackCuts.cxx:2416
 AliFlowTrackCuts.cxx:2417
 AliFlowTrackCuts.cxx:2418
 AliFlowTrackCuts.cxx:2419
 AliFlowTrackCuts.cxx:2420
 AliFlowTrackCuts.cxx:2421
 AliFlowTrackCuts.cxx:2422
 AliFlowTrackCuts.cxx:2423
 AliFlowTrackCuts.cxx:2424
 AliFlowTrackCuts.cxx:2425
 AliFlowTrackCuts.cxx:2426
 AliFlowTrackCuts.cxx:2427
 AliFlowTrackCuts.cxx:2428
 AliFlowTrackCuts.cxx:2429
 AliFlowTrackCuts.cxx:2430
 AliFlowTrackCuts.cxx:2431
 AliFlowTrackCuts.cxx:2432
 AliFlowTrackCuts.cxx:2433
 AliFlowTrackCuts.cxx:2434
 AliFlowTrackCuts.cxx:2435
 AliFlowTrackCuts.cxx:2436
 AliFlowTrackCuts.cxx:2437
 AliFlowTrackCuts.cxx:2438
 AliFlowTrackCuts.cxx:2439
 AliFlowTrackCuts.cxx:2440
 AliFlowTrackCuts.cxx:2441
 AliFlowTrackCuts.cxx:2442
 AliFlowTrackCuts.cxx:2443
 AliFlowTrackCuts.cxx:2444
 AliFlowTrackCuts.cxx:2445
 AliFlowTrackCuts.cxx:2446
 AliFlowTrackCuts.cxx:2447
 AliFlowTrackCuts.cxx:2448
 AliFlowTrackCuts.cxx:2449
 AliFlowTrackCuts.cxx:2450
 AliFlowTrackCuts.cxx:2451
 AliFlowTrackCuts.cxx:2452
 AliFlowTrackCuts.cxx:2453
 AliFlowTrackCuts.cxx:2454
 AliFlowTrackCuts.cxx:2455
 AliFlowTrackCuts.cxx:2456
 AliFlowTrackCuts.cxx:2457
 AliFlowTrackCuts.cxx:2458
 AliFlowTrackCuts.cxx:2459
 AliFlowTrackCuts.cxx:2460
 AliFlowTrackCuts.cxx:2461
 AliFlowTrackCuts.cxx:2462
 AliFlowTrackCuts.cxx:2463
 AliFlowTrackCuts.cxx:2464
 AliFlowTrackCuts.cxx:2465
 AliFlowTrackCuts.cxx:2466
 AliFlowTrackCuts.cxx:2467
 AliFlowTrackCuts.cxx:2468
 AliFlowTrackCuts.cxx:2469
 AliFlowTrackCuts.cxx:2470
 AliFlowTrackCuts.cxx:2471
 AliFlowTrackCuts.cxx:2472
 AliFlowTrackCuts.cxx:2473
 AliFlowTrackCuts.cxx:2474
 AliFlowTrackCuts.cxx:2475
 AliFlowTrackCuts.cxx:2476
 AliFlowTrackCuts.cxx:2477
 AliFlowTrackCuts.cxx:2478
 AliFlowTrackCuts.cxx:2479
 AliFlowTrackCuts.cxx:2480
 AliFlowTrackCuts.cxx:2481
 AliFlowTrackCuts.cxx:2482
 AliFlowTrackCuts.cxx:2483
 AliFlowTrackCuts.cxx:2484
 AliFlowTrackCuts.cxx:2485
 AliFlowTrackCuts.cxx:2486
 AliFlowTrackCuts.cxx:2487
 AliFlowTrackCuts.cxx:2488
 AliFlowTrackCuts.cxx:2489
 AliFlowTrackCuts.cxx:2490
 AliFlowTrackCuts.cxx:2491
 AliFlowTrackCuts.cxx:2492
 AliFlowTrackCuts.cxx:2493
 AliFlowTrackCuts.cxx:2494
 AliFlowTrackCuts.cxx:2495
 AliFlowTrackCuts.cxx:2496
 AliFlowTrackCuts.cxx:2497
 AliFlowTrackCuts.cxx:2498
 AliFlowTrackCuts.cxx:2499
 AliFlowTrackCuts.cxx:2500
 AliFlowTrackCuts.cxx:2501
 AliFlowTrackCuts.cxx:2502
 AliFlowTrackCuts.cxx:2503
 AliFlowTrackCuts.cxx:2504
 AliFlowTrackCuts.cxx:2505
 AliFlowTrackCuts.cxx:2506
 AliFlowTrackCuts.cxx:2507
 AliFlowTrackCuts.cxx:2508
 AliFlowTrackCuts.cxx:2509
 AliFlowTrackCuts.cxx:2510
 AliFlowTrackCuts.cxx:2511
 AliFlowTrackCuts.cxx:2512
 AliFlowTrackCuts.cxx:2513
 AliFlowTrackCuts.cxx:2514
 AliFlowTrackCuts.cxx:2515
 AliFlowTrackCuts.cxx:2516
 AliFlowTrackCuts.cxx:2517
 AliFlowTrackCuts.cxx:2518
 AliFlowTrackCuts.cxx:2519
 AliFlowTrackCuts.cxx:2520
 AliFlowTrackCuts.cxx:2521
 AliFlowTrackCuts.cxx:2522
 AliFlowTrackCuts.cxx:2523
 AliFlowTrackCuts.cxx:2524
 AliFlowTrackCuts.cxx:2525
 AliFlowTrackCuts.cxx:2526
 AliFlowTrackCuts.cxx:2527
 AliFlowTrackCuts.cxx:2528
 AliFlowTrackCuts.cxx:2529
 AliFlowTrackCuts.cxx:2530
 AliFlowTrackCuts.cxx:2531
 AliFlowTrackCuts.cxx:2532
 AliFlowTrackCuts.cxx:2533
 AliFlowTrackCuts.cxx:2534
 AliFlowTrackCuts.cxx:2535
 AliFlowTrackCuts.cxx:2536
 AliFlowTrackCuts.cxx:2537
 AliFlowTrackCuts.cxx:2538
 AliFlowTrackCuts.cxx:2539
 AliFlowTrackCuts.cxx:2540
 AliFlowTrackCuts.cxx:2541
 AliFlowTrackCuts.cxx:2542
 AliFlowTrackCuts.cxx:2543
 AliFlowTrackCuts.cxx:2544
 AliFlowTrackCuts.cxx:2545
 AliFlowTrackCuts.cxx:2546
 AliFlowTrackCuts.cxx:2547
 AliFlowTrackCuts.cxx:2548
 AliFlowTrackCuts.cxx:2549
 AliFlowTrackCuts.cxx:2550
 AliFlowTrackCuts.cxx:2551
 AliFlowTrackCuts.cxx:2552
 AliFlowTrackCuts.cxx:2553
 AliFlowTrackCuts.cxx:2554
 AliFlowTrackCuts.cxx:2555
 AliFlowTrackCuts.cxx:2556
 AliFlowTrackCuts.cxx:2557
 AliFlowTrackCuts.cxx:2558
 AliFlowTrackCuts.cxx:2559
 AliFlowTrackCuts.cxx:2560
 AliFlowTrackCuts.cxx:2561
 AliFlowTrackCuts.cxx:2562
 AliFlowTrackCuts.cxx:2563
 AliFlowTrackCuts.cxx:2564
 AliFlowTrackCuts.cxx:2565
 AliFlowTrackCuts.cxx:2566
 AliFlowTrackCuts.cxx:2567
 AliFlowTrackCuts.cxx:2568
 AliFlowTrackCuts.cxx:2569
 AliFlowTrackCuts.cxx:2570
 AliFlowTrackCuts.cxx:2571
 AliFlowTrackCuts.cxx:2572
 AliFlowTrackCuts.cxx:2573
 AliFlowTrackCuts.cxx:2574
 AliFlowTrackCuts.cxx:2575
 AliFlowTrackCuts.cxx:2576
 AliFlowTrackCuts.cxx:2577
 AliFlowTrackCuts.cxx:2578
 AliFlowTrackCuts.cxx:2579
 AliFlowTrackCuts.cxx:2580
 AliFlowTrackCuts.cxx:2581
 AliFlowTrackCuts.cxx:2582
 AliFlowTrackCuts.cxx:2583
 AliFlowTrackCuts.cxx:2584
 AliFlowTrackCuts.cxx:2585
 AliFlowTrackCuts.cxx:2586
 AliFlowTrackCuts.cxx:2587
 AliFlowTrackCuts.cxx:2588
 AliFlowTrackCuts.cxx:2589
 AliFlowTrackCuts.cxx:2590
 AliFlowTrackCuts.cxx:2591
 AliFlowTrackCuts.cxx:2592
 AliFlowTrackCuts.cxx:2593
 AliFlowTrackCuts.cxx:2594
 AliFlowTrackCuts.cxx:2595
 AliFlowTrackCuts.cxx:2596
 AliFlowTrackCuts.cxx:2597
 AliFlowTrackCuts.cxx:2598
 AliFlowTrackCuts.cxx:2599
 AliFlowTrackCuts.cxx:2600
 AliFlowTrackCuts.cxx:2601
 AliFlowTrackCuts.cxx:2602
 AliFlowTrackCuts.cxx:2603
 AliFlowTrackCuts.cxx:2604
 AliFlowTrackCuts.cxx:2605
 AliFlowTrackCuts.cxx:2606
 AliFlowTrackCuts.cxx:2607
 AliFlowTrackCuts.cxx:2608
 AliFlowTrackCuts.cxx:2609
 AliFlowTrackCuts.cxx:2610
 AliFlowTrackCuts.cxx:2611
 AliFlowTrackCuts.cxx:2612
 AliFlowTrackCuts.cxx:2613
 AliFlowTrackCuts.cxx:2614
 AliFlowTrackCuts.cxx:2615
 AliFlowTrackCuts.cxx:2616
 AliFlowTrackCuts.cxx:2617
 AliFlowTrackCuts.cxx:2618
 AliFlowTrackCuts.cxx:2619
 AliFlowTrackCuts.cxx:2620
 AliFlowTrackCuts.cxx:2621
 AliFlowTrackCuts.cxx:2622
 AliFlowTrackCuts.cxx:2623
 AliFlowTrackCuts.cxx:2624
 AliFlowTrackCuts.cxx:2625
 AliFlowTrackCuts.cxx:2626
 AliFlowTrackCuts.cxx:2627
 AliFlowTrackCuts.cxx:2628
 AliFlowTrackCuts.cxx:2629
 AliFlowTrackCuts.cxx:2630
 AliFlowTrackCuts.cxx:2631
 AliFlowTrackCuts.cxx:2632
 AliFlowTrackCuts.cxx:2633
 AliFlowTrackCuts.cxx:2634
 AliFlowTrackCuts.cxx:2635
 AliFlowTrackCuts.cxx:2636
 AliFlowTrackCuts.cxx:2637
 AliFlowTrackCuts.cxx:2638
 AliFlowTrackCuts.cxx:2639
 AliFlowTrackCuts.cxx:2640
 AliFlowTrackCuts.cxx:2641
 AliFlowTrackCuts.cxx:2642
 AliFlowTrackCuts.cxx:2643
 AliFlowTrackCuts.cxx:2644
 AliFlowTrackCuts.cxx:2645
 AliFlowTrackCuts.cxx:2646
 AliFlowTrackCuts.cxx:2647
 AliFlowTrackCuts.cxx:2648
 AliFlowTrackCuts.cxx:2649
 AliFlowTrackCuts.cxx:2650
 AliFlowTrackCuts.cxx:2651
 AliFlowTrackCuts.cxx:2652
 AliFlowTrackCuts.cxx:2653
 AliFlowTrackCuts.cxx:2654
 AliFlowTrackCuts.cxx:2655
 AliFlowTrackCuts.cxx:2656
 AliFlowTrackCuts.cxx:2657
 AliFlowTrackCuts.cxx:2658
 AliFlowTrackCuts.cxx:2659
 AliFlowTrackCuts.cxx:2660
 AliFlowTrackCuts.cxx:2661
 AliFlowTrackCuts.cxx:2662
 AliFlowTrackCuts.cxx:2663
 AliFlowTrackCuts.cxx:2664
 AliFlowTrackCuts.cxx:2665
 AliFlowTrackCuts.cxx:2666
 AliFlowTrackCuts.cxx:2667
 AliFlowTrackCuts.cxx:2668
 AliFlowTrackCuts.cxx:2669
 AliFlowTrackCuts.cxx:2670
 AliFlowTrackCuts.cxx:2671
 AliFlowTrackCuts.cxx:2672
 AliFlowTrackCuts.cxx:2673
 AliFlowTrackCuts.cxx:2674
 AliFlowTrackCuts.cxx:2675
 AliFlowTrackCuts.cxx:2676
 AliFlowTrackCuts.cxx:2677
 AliFlowTrackCuts.cxx:2678
 AliFlowTrackCuts.cxx:2679
 AliFlowTrackCuts.cxx:2680
 AliFlowTrackCuts.cxx:2681
 AliFlowTrackCuts.cxx:2682
 AliFlowTrackCuts.cxx:2683
 AliFlowTrackCuts.cxx:2684
 AliFlowTrackCuts.cxx:2685
 AliFlowTrackCuts.cxx:2686
 AliFlowTrackCuts.cxx:2687
 AliFlowTrackCuts.cxx:2688
 AliFlowTrackCuts.cxx:2689
 AliFlowTrackCuts.cxx:2690
 AliFlowTrackCuts.cxx:2691
 AliFlowTrackCuts.cxx:2692
 AliFlowTrackCuts.cxx:2693
 AliFlowTrackCuts.cxx:2694
 AliFlowTrackCuts.cxx:2695
 AliFlowTrackCuts.cxx:2696
 AliFlowTrackCuts.cxx:2697
 AliFlowTrackCuts.cxx:2698
 AliFlowTrackCuts.cxx:2699
 AliFlowTrackCuts.cxx:2700
 AliFlowTrackCuts.cxx:2701
 AliFlowTrackCuts.cxx:2702
 AliFlowTrackCuts.cxx:2703
 AliFlowTrackCuts.cxx:2704
 AliFlowTrackCuts.cxx:2705
 AliFlowTrackCuts.cxx:2706
 AliFlowTrackCuts.cxx:2707
 AliFlowTrackCuts.cxx:2708
 AliFlowTrackCuts.cxx:2709
 AliFlowTrackCuts.cxx:2710
 AliFlowTrackCuts.cxx:2711
 AliFlowTrackCuts.cxx:2712
 AliFlowTrackCuts.cxx:2713
 AliFlowTrackCuts.cxx:2714
 AliFlowTrackCuts.cxx:2715
 AliFlowTrackCuts.cxx:2716
 AliFlowTrackCuts.cxx:2717
 AliFlowTrackCuts.cxx:2718
 AliFlowTrackCuts.cxx:2719
 AliFlowTrackCuts.cxx:2720
 AliFlowTrackCuts.cxx:2721
 AliFlowTrackCuts.cxx:2722
 AliFlowTrackCuts.cxx:2723
 AliFlowTrackCuts.cxx:2724
 AliFlowTrackCuts.cxx:2725
 AliFlowTrackCuts.cxx:2726
 AliFlowTrackCuts.cxx:2727
 AliFlowTrackCuts.cxx:2728
 AliFlowTrackCuts.cxx:2729
 AliFlowTrackCuts.cxx:2730
 AliFlowTrackCuts.cxx:2731
 AliFlowTrackCuts.cxx:2732
 AliFlowTrackCuts.cxx:2733
 AliFlowTrackCuts.cxx:2734
 AliFlowTrackCuts.cxx:2735
 AliFlowTrackCuts.cxx:2736
 AliFlowTrackCuts.cxx:2737
 AliFlowTrackCuts.cxx:2738
 AliFlowTrackCuts.cxx:2739
 AliFlowTrackCuts.cxx:2740
 AliFlowTrackCuts.cxx:2741
 AliFlowTrackCuts.cxx:2742
 AliFlowTrackCuts.cxx:2743
 AliFlowTrackCuts.cxx:2744
 AliFlowTrackCuts.cxx:2745
 AliFlowTrackCuts.cxx:2746
 AliFlowTrackCuts.cxx:2747
 AliFlowTrackCuts.cxx:2748
 AliFlowTrackCuts.cxx:2749
 AliFlowTrackCuts.cxx:2750
 AliFlowTrackCuts.cxx:2751
 AliFlowTrackCuts.cxx:2752
 AliFlowTrackCuts.cxx:2753
 AliFlowTrackCuts.cxx:2754
 AliFlowTrackCuts.cxx:2755
 AliFlowTrackCuts.cxx:2756
 AliFlowTrackCuts.cxx:2757
 AliFlowTrackCuts.cxx:2758
 AliFlowTrackCuts.cxx:2759
 AliFlowTrackCuts.cxx:2760
 AliFlowTrackCuts.cxx:2761
 AliFlowTrackCuts.cxx:2762
 AliFlowTrackCuts.cxx:2763
 AliFlowTrackCuts.cxx:2764
 AliFlowTrackCuts.cxx:2765
 AliFlowTrackCuts.cxx:2766
 AliFlowTrackCuts.cxx:2767
 AliFlowTrackCuts.cxx:2768
 AliFlowTrackCuts.cxx:2769
 AliFlowTrackCuts.cxx:2770
 AliFlowTrackCuts.cxx:2771
 AliFlowTrackCuts.cxx:2772
 AliFlowTrackCuts.cxx:2773
 AliFlowTrackCuts.cxx:2774
 AliFlowTrackCuts.cxx:2775
 AliFlowTrackCuts.cxx:2776
 AliFlowTrackCuts.cxx:2777
 AliFlowTrackCuts.cxx:2778
 AliFlowTrackCuts.cxx:2779
 AliFlowTrackCuts.cxx:2780
 AliFlowTrackCuts.cxx:2781
 AliFlowTrackCuts.cxx:2782
 AliFlowTrackCuts.cxx:2783
 AliFlowTrackCuts.cxx:2784
 AliFlowTrackCuts.cxx:2785
 AliFlowTrackCuts.cxx:2786
 AliFlowTrackCuts.cxx:2787
 AliFlowTrackCuts.cxx:2788
 AliFlowTrackCuts.cxx:2789
 AliFlowTrackCuts.cxx:2790
 AliFlowTrackCuts.cxx:2791
 AliFlowTrackCuts.cxx:2792
 AliFlowTrackCuts.cxx:2793
 AliFlowTrackCuts.cxx:2794
 AliFlowTrackCuts.cxx:2795
 AliFlowTrackCuts.cxx:2796
 AliFlowTrackCuts.cxx:2797
 AliFlowTrackCuts.cxx:2798
 AliFlowTrackCuts.cxx:2799
 AliFlowTrackCuts.cxx:2800
 AliFlowTrackCuts.cxx:2801
 AliFlowTrackCuts.cxx:2802
 AliFlowTrackCuts.cxx:2803
 AliFlowTrackCuts.cxx:2804
 AliFlowTrackCuts.cxx:2805
 AliFlowTrackCuts.cxx:2806
 AliFlowTrackCuts.cxx:2807
 AliFlowTrackCuts.cxx:2808
 AliFlowTrackCuts.cxx:2809
 AliFlowTrackCuts.cxx:2810
 AliFlowTrackCuts.cxx:2811
 AliFlowTrackCuts.cxx:2812
 AliFlowTrackCuts.cxx:2813
 AliFlowTrackCuts.cxx:2814
 AliFlowTrackCuts.cxx:2815
 AliFlowTrackCuts.cxx:2816
 AliFlowTrackCuts.cxx:2817
 AliFlowTrackCuts.cxx:2818
 AliFlowTrackCuts.cxx:2819
 AliFlowTrackCuts.cxx:2820
 AliFlowTrackCuts.cxx:2821
 AliFlowTrackCuts.cxx:2822
 AliFlowTrackCuts.cxx:2823
 AliFlowTrackCuts.cxx:2824
 AliFlowTrackCuts.cxx:2825
 AliFlowTrackCuts.cxx:2826
 AliFlowTrackCuts.cxx:2827
 AliFlowTrackCuts.cxx:2828
 AliFlowTrackCuts.cxx:2829
 AliFlowTrackCuts.cxx:2830
 AliFlowTrackCuts.cxx:2831
 AliFlowTrackCuts.cxx:2832
 AliFlowTrackCuts.cxx:2833
 AliFlowTrackCuts.cxx:2834
 AliFlowTrackCuts.cxx:2835
 AliFlowTrackCuts.cxx:2836
 AliFlowTrackCuts.cxx:2837
 AliFlowTrackCuts.cxx:2838
 AliFlowTrackCuts.cxx:2839
 AliFlowTrackCuts.cxx:2840
 AliFlowTrackCuts.cxx:2841
 AliFlowTrackCuts.cxx:2842
 AliFlowTrackCuts.cxx:2843
 AliFlowTrackCuts.cxx:2844
 AliFlowTrackCuts.cxx:2845
 AliFlowTrackCuts.cxx:2846
 AliFlowTrackCuts.cxx:2847
 AliFlowTrackCuts.cxx:2848
 AliFlowTrackCuts.cxx:2849
 AliFlowTrackCuts.cxx:2850
 AliFlowTrackCuts.cxx:2851
 AliFlowTrackCuts.cxx:2852
 AliFlowTrackCuts.cxx:2853
 AliFlowTrackCuts.cxx:2854
 AliFlowTrackCuts.cxx:2855
 AliFlowTrackCuts.cxx:2856
 AliFlowTrackCuts.cxx:2857
 AliFlowTrackCuts.cxx:2858
 AliFlowTrackCuts.cxx:2859
 AliFlowTrackCuts.cxx:2860
 AliFlowTrackCuts.cxx:2861
 AliFlowTrackCuts.cxx:2862
 AliFlowTrackCuts.cxx:2863
 AliFlowTrackCuts.cxx:2864
 AliFlowTrackCuts.cxx:2865
 AliFlowTrackCuts.cxx:2866
 AliFlowTrackCuts.cxx:2867
 AliFlowTrackCuts.cxx:2868
 AliFlowTrackCuts.cxx:2869
 AliFlowTrackCuts.cxx:2870
 AliFlowTrackCuts.cxx:2871
 AliFlowTrackCuts.cxx:2872
 AliFlowTrackCuts.cxx:2873
 AliFlowTrackCuts.cxx:2874
 AliFlowTrackCuts.cxx:2875
 AliFlowTrackCuts.cxx:2876
 AliFlowTrackCuts.cxx:2877
 AliFlowTrackCuts.cxx:2878
 AliFlowTrackCuts.cxx:2879
 AliFlowTrackCuts.cxx:2880
 AliFlowTrackCuts.cxx:2881
 AliFlowTrackCuts.cxx:2882
 AliFlowTrackCuts.cxx:2883
 AliFlowTrackCuts.cxx:2884
 AliFlowTrackCuts.cxx:2885
 AliFlowTrackCuts.cxx:2886
 AliFlowTrackCuts.cxx:2887
 AliFlowTrackCuts.cxx:2888
 AliFlowTrackCuts.cxx:2889
 AliFlowTrackCuts.cxx:2890
 AliFlowTrackCuts.cxx:2891
 AliFlowTrackCuts.cxx:2892
 AliFlowTrackCuts.cxx:2893
 AliFlowTrackCuts.cxx:2894
 AliFlowTrackCuts.cxx:2895
 AliFlowTrackCuts.cxx:2896
 AliFlowTrackCuts.cxx:2897
 AliFlowTrackCuts.cxx:2898
 AliFlowTrackCuts.cxx:2899
 AliFlowTrackCuts.cxx:2900
 AliFlowTrackCuts.cxx:2901
 AliFlowTrackCuts.cxx:2902
 AliFlowTrackCuts.cxx:2903
 AliFlowTrackCuts.cxx:2904
 AliFlowTrackCuts.cxx:2905
 AliFlowTrackCuts.cxx:2906
 AliFlowTrackCuts.cxx:2907
 AliFlowTrackCuts.cxx:2908
 AliFlowTrackCuts.cxx:2909
 AliFlowTrackCuts.cxx:2910
 AliFlowTrackCuts.cxx:2911
 AliFlowTrackCuts.cxx:2912
 AliFlowTrackCuts.cxx:2913
 AliFlowTrackCuts.cxx:2914
 AliFlowTrackCuts.cxx:2915
 AliFlowTrackCuts.cxx:2916
 AliFlowTrackCuts.cxx:2917
 AliFlowTrackCuts.cxx:2918
 AliFlowTrackCuts.cxx:2919
 AliFlowTrackCuts.cxx:2920
 AliFlowTrackCuts.cxx:2921
 AliFlowTrackCuts.cxx:2922
 AliFlowTrackCuts.cxx:2923
 AliFlowTrackCuts.cxx:2924
 AliFlowTrackCuts.cxx:2925
 AliFlowTrackCuts.cxx:2926
 AliFlowTrackCuts.cxx:2927
 AliFlowTrackCuts.cxx:2928
 AliFlowTrackCuts.cxx:2929
 AliFlowTrackCuts.cxx:2930
 AliFlowTrackCuts.cxx:2931
 AliFlowTrackCuts.cxx:2932
 AliFlowTrackCuts.cxx:2933
 AliFlowTrackCuts.cxx:2934
 AliFlowTrackCuts.cxx:2935
 AliFlowTrackCuts.cxx:2936
 AliFlowTrackCuts.cxx:2937
 AliFlowTrackCuts.cxx:2938
 AliFlowTrackCuts.cxx:2939
 AliFlowTrackCuts.cxx:2940
 AliFlowTrackCuts.cxx:2941
 AliFlowTrackCuts.cxx:2942
 AliFlowTrackCuts.cxx:2943
 AliFlowTrackCuts.cxx:2944
 AliFlowTrackCuts.cxx:2945
 AliFlowTrackCuts.cxx:2946
 AliFlowTrackCuts.cxx:2947
 AliFlowTrackCuts.cxx:2948
 AliFlowTrackCuts.cxx:2949
 AliFlowTrackCuts.cxx:2950
 AliFlowTrackCuts.cxx:2951
 AliFlowTrackCuts.cxx:2952
 AliFlowTrackCuts.cxx:2953
 AliFlowTrackCuts.cxx:2954
 AliFlowTrackCuts.cxx:2955
 AliFlowTrackCuts.cxx:2956
 AliFlowTrackCuts.cxx:2957
 AliFlowTrackCuts.cxx:2958
 AliFlowTrackCuts.cxx:2959
 AliFlowTrackCuts.cxx:2960
 AliFlowTrackCuts.cxx:2961
 AliFlowTrackCuts.cxx:2962
 AliFlowTrackCuts.cxx:2963
 AliFlowTrackCuts.cxx:2964
 AliFlowTrackCuts.cxx:2965
 AliFlowTrackCuts.cxx:2966
 AliFlowTrackCuts.cxx:2967
 AliFlowTrackCuts.cxx:2968
 AliFlowTrackCuts.cxx:2969
 AliFlowTrackCuts.cxx:2970
 AliFlowTrackCuts.cxx:2971
 AliFlowTrackCuts.cxx:2972
 AliFlowTrackCuts.cxx:2973
 AliFlowTrackCuts.cxx:2974
 AliFlowTrackCuts.cxx:2975
 AliFlowTrackCuts.cxx:2976
 AliFlowTrackCuts.cxx:2977
 AliFlowTrackCuts.cxx:2978
 AliFlowTrackCuts.cxx:2979
 AliFlowTrackCuts.cxx:2980
 AliFlowTrackCuts.cxx:2981
 AliFlowTrackCuts.cxx:2982
 AliFlowTrackCuts.cxx:2983
 AliFlowTrackCuts.cxx:2984
 AliFlowTrackCuts.cxx:2985
 AliFlowTrackCuts.cxx:2986
 AliFlowTrackCuts.cxx:2987
 AliFlowTrackCuts.cxx:2988
 AliFlowTrackCuts.cxx:2989
 AliFlowTrackCuts.cxx:2990
 AliFlowTrackCuts.cxx:2991
 AliFlowTrackCuts.cxx:2992
 AliFlowTrackCuts.cxx:2993
 AliFlowTrackCuts.cxx:2994
 AliFlowTrackCuts.cxx:2995
 AliFlowTrackCuts.cxx:2996
 AliFlowTrackCuts.cxx:2997
 AliFlowTrackCuts.cxx:2998
 AliFlowTrackCuts.cxx:2999
 AliFlowTrackCuts.cxx:3000
 AliFlowTrackCuts.cxx:3001
 AliFlowTrackCuts.cxx:3002
 AliFlowTrackCuts.cxx:3003
 AliFlowTrackCuts.cxx:3004
 AliFlowTrackCuts.cxx:3005
 AliFlowTrackCuts.cxx:3006
 AliFlowTrackCuts.cxx:3007
 AliFlowTrackCuts.cxx:3008
 AliFlowTrackCuts.cxx:3009
 AliFlowTrackCuts.cxx:3010
 AliFlowTrackCuts.cxx:3011
 AliFlowTrackCuts.cxx:3012
 AliFlowTrackCuts.cxx:3013
 AliFlowTrackCuts.cxx:3014
 AliFlowTrackCuts.cxx:3015
 AliFlowTrackCuts.cxx:3016
 AliFlowTrackCuts.cxx:3017
 AliFlowTrackCuts.cxx:3018
 AliFlowTrackCuts.cxx:3019
 AliFlowTrackCuts.cxx:3020
 AliFlowTrackCuts.cxx:3021
 AliFlowTrackCuts.cxx:3022
 AliFlowTrackCuts.cxx:3023
 AliFlowTrackCuts.cxx:3024
 AliFlowTrackCuts.cxx:3025
 AliFlowTrackCuts.cxx:3026
 AliFlowTrackCuts.cxx:3027
 AliFlowTrackCuts.cxx:3028
 AliFlowTrackCuts.cxx:3029
 AliFlowTrackCuts.cxx:3030
 AliFlowTrackCuts.cxx:3031
 AliFlowTrackCuts.cxx:3032
 AliFlowTrackCuts.cxx:3033
 AliFlowTrackCuts.cxx:3034
 AliFlowTrackCuts.cxx:3035
 AliFlowTrackCuts.cxx:3036
 AliFlowTrackCuts.cxx:3037
 AliFlowTrackCuts.cxx:3038
 AliFlowTrackCuts.cxx:3039
 AliFlowTrackCuts.cxx:3040
 AliFlowTrackCuts.cxx:3041
 AliFlowTrackCuts.cxx:3042
 AliFlowTrackCuts.cxx:3043
 AliFlowTrackCuts.cxx:3044
 AliFlowTrackCuts.cxx:3045
 AliFlowTrackCuts.cxx:3046
 AliFlowTrackCuts.cxx:3047
 AliFlowTrackCuts.cxx:3048
 AliFlowTrackCuts.cxx:3049
 AliFlowTrackCuts.cxx:3050
 AliFlowTrackCuts.cxx:3051
 AliFlowTrackCuts.cxx:3052
 AliFlowTrackCuts.cxx:3053
 AliFlowTrackCuts.cxx:3054
 AliFlowTrackCuts.cxx:3055
 AliFlowTrackCuts.cxx:3056
 AliFlowTrackCuts.cxx:3057
 AliFlowTrackCuts.cxx:3058
 AliFlowTrackCuts.cxx:3059
 AliFlowTrackCuts.cxx:3060
 AliFlowTrackCuts.cxx:3061
 AliFlowTrackCuts.cxx:3062
 AliFlowTrackCuts.cxx:3063
 AliFlowTrackCuts.cxx:3064
 AliFlowTrackCuts.cxx:3065
 AliFlowTrackCuts.cxx:3066
 AliFlowTrackCuts.cxx:3067
 AliFlowTrackCuts.cxx:3068
 AliFlowTrackCuts.cxx:3069
 AliFlowTrackCuts.cxx:3070
 AliFlowTrackCuts.cxx:3071
 AliFlowTrackCuts.cxx:3072
 AliFlowTrackCuts.cxx:3073
 AliFlowTrackCuts.cxx:3074
 AliFlowTrackCuts.cxx:3075
 AliFlowTrackCuts.cxx:3076
 AliFlowTrackCuts.cxx:3077
 AliFlowTrackCuts.cxx:3078
 AliFlowTrackCuts.cxx:3079
 AliFlowTrackCuts.cxx:3080
 AliFlowTrackCuts.cxx:3081
 AliFlowTrackCuts.cxx:3082
 AliFlowTrackCuts.cxx:3083
 AliFlowTrackCuts.cxx:3084
 AliFlowTrackCuts.cxx:3085
 AliFlowTrackCuts.cxx:3086
 AliFlowTrackCuts.cxx:3087
 AliFlowTrackCuts.cxx:3088
 AliFlowTrackCuts.cxx:3089
 AliFlowTrackCuts.cxx:3090
 AliFlowTrackCuts.cxx:3091
 AliFlowTrackCuts.cxx:3092
 AliFlowTrackCuts.cxx:3093
 AliFlowTrackCuts.cxx:3094
 AliFlowTrackCuts.cxx:3095
 AliFlowTrackCuts.cxx:3096
 AliFlowTrackCuts.cxx:3097
 AliFlowTrackCuts.cxx:3098
 AliFlowTrackCuts.cxx:3099
 AliFlowTrackCuts.cxx:3100
 AliFlowTrackCuts.cxx:3101
 AliFlowTrackCuts.cxx:3102
 AliFlowTrackCuts.cxx:3103
 AliFlowTrackCuts.cxx:3104
 AliFlowTrackCuts.cxx:3105
 AliFlowTrackCuts.cxx:3106
 AliFlowTrackCuts.cxx:3107
 AliFlowTrackCuts.cxx:3108
 AliFlowTrackCuts.cxx:3109
 AliFlowTrackCuts.cxx:3110
 AliFlowTrackCuts.cxx:3111
 AliFlowTrackCuts.cxx:3112
 AliFlowTrackCuts.cxx:3113
 AliFlowTrackCuts.cxx:3114
 AliFlowTrackCuts.cxx:3115
 AliFlowTrackCuts.cxx:3116
 AliFlowTrackCuts.cxx:3117
 AliFlowTrackCuts.cxx:3118
 AliFlowTrackCuts.cxx:3119
 AliFlowTrackCuts.cxx:3120
 AliFlowTrackCuts.cxx:3121
 AliFlowTrackCuts.cxx:3122
 AliFlowTrackCuts.cxx:3123
 AliFlowTrackCuts.cxx:3124
 AliFlowTrackCuts.cxx:3125
 AliFlowTrackCuts.cxx:3126
 AliFlowTrackCuts.cxx:3127
 AliFlowTrackCuts.cxx:3128
 AliFlowTrackCuts.cxx:3129
 AliFlowTrackCuts.cxx:3130
 AliFlowTrackCuts.cxx:3131
 AliFlowTrackCuts.cxx:3132
 AliFlowTrackCuts.cxx:3133
 AliFlowTrackCuts.cxx:3134
 AliFlowTrackCuts.cxx:3135
 AliFlowTrackCuts.cxx:3136
 AliFlowTrackCuts.cxx:3137
 AliFlowTrackCuts.cxx:3138
 AliFlowTrackCuts.cxx:3139
 AliFlowTrackCuts.cxx:3140
 AliFlowTrackCuts.cxx:3141
 AliFlowTrackCuts.cxx:3142
 AliFlowTrackCuts.cxx:3143
 AliFlowTrackCuts.cxx:3144
 AliFlowTrackCuts.cxx:3145
 AliFlowTrackCuts.cxx:3146
 AliFlowTrackCuts.cxx:3147
 AliFlowTrackCuts.cxx:3148
 AliFlowTrackCuts.cxx:3149
 AliFlowTrackCuts.cxx:3150
 AliFlowTrackCuts.cxx:3151
 AliFlowTrackCuts.cxx:3152
 AliFlowTrackCuts.cxx:3153
 AliFlowTrackCuts.cxx:3154
 AliFlowTrackCuts.cxx:3155
 AliFlowTrackCuts.cxx:3156
 AliFlowTrackCuts.cxx:3157
 AliFlowTrackCuts.cxx:3158
 AliFlowTrackCuts.cxx:3159
 AliFlowTrackCuts.cxx:3160
 AliFlowTrackCuts.cxx:3161
 AliFlowTrackCuts.cxx:3162
 AliFlowTrackCuts.cxx:3163
 AliFlowTrackCuts.cxx:3164
 AliFlowTrackCuts.cxx:3165
 AliFlowTrackCuts.cxx:3166
 AliFlowTrackCuts.cxx:3167
 AliFlowTrackCuts.cxx:3168
 AliFlowTrackCuts.cxx:3169
 AliFlowTrackCuts.cxx:3170
 AliFlowTrackCuts.cxx:3171
 AliFlowTrackCuts.cxx:3172
 AliFlowTrackCuts.cxx:3173
 AliFlowTrackCuts.cxx:3174
 AliFlowTrackCuts.cxx:3175
 AliFlowTrackCuts.cxx:3176
 AliFlowTrackCuts.cxx:3177
 AliFlowTrackCuts.cxx:3178
 AliFlowTrackCuts.cxx:3179
 AliFlowTrackCuts.cxx:3180
 AliFlowTrackCuts.cxx:3181
 AliFlowTrackCuts.cxx:3182
 AliFlowTrackCuts.cxx:3183
 AliFlowTrackCuts.cxx:3184
 AliFlowTrackCuts.cxx:3185
 AliFlowTrackCuts.cxx:3186
 AliFlowTrackCuts.cxx:3187
 AliFlowTrackCuts.cxx:3188
 AliFlowTrackCuts.cxx:3189
 AliFlowTrackCuts.cxx:3190
 AliFlowTrackCuts.cxx:3191
 AliFlowTrackCuts.cxx:3192
 AliFlowTrackCuts.cxx:3193
 AliFlowTrackCuts.cxx:3194
 AliFlowTrackCuts.cxx:3195
 AliFlowTrackCuts.cxx:3196
 AliFlowTrackCuts.cxx:3197
 AliFlowTrackCuts.cxx:3198
 AliFlowTrackCuts.cxx:3199
 AliFlowTrackCuts.cxx:3200
 AliFlowTrackCuts.cxx:3201
 AliFlowTrackCuts.cxx:3202
 AliFlowTrackCuts.cxx:3203
 AliFlowTrackCuts.cxx:3204
 AliFlowTrackCuts.cxx:3205
 AliFlowTrackCuts.cxx:3206
 AliFlowTrackCuts.cxx:3207
 AliFlowTrackCuts.cxx:3208
 AliFlowTrackCuts.cxx:3209
 AliFlowTrackCuts.cxx:3210
 AliFlowTrackCuts.cxx:3211
 AliFlowTrackCuts.cxx:3212
 AliFlowTrackCuts.cxx:3213
 AliFlowTrackCuts.cxx:3214
 AliFlowTrackCuts.cxx:3215
 AliFlowTrackCuts.cxx:3216
 AliFlowTrackCuts.cxx:3217
 AliFlowTrackCuts.cxx:3218
 AliFlowTrackCuts.cxx:3219
 AliFlowTrackCuts.cxx:3220
 AliFlowTrackCuts.cxx:3221
 AliFlowTrackCuts.cxx:3222
 AliFlowTrackCuts.cxx:3223
 AliFlowTrackCuts.cxx:3224
 AliFlowTrackCuts.cxx:3225
 AliFlowTrackCuts.cxx:3226
 AliFlowTrackCuts.cxx:3227
 AliFlowTrackCuts.cxx:3228
 AliFlowTrackCuts.cxx:3229
 AliFlowTrackCuts.cxx:3230
 AliFlowTrackCuts.cxx:3231
 AliFlowTrackCuts.cxx:3232
 AliFlowTrackCuts.cxx:3233
 AliFlowTrackCuts.cxx:3234
 AliFlowTrackCuts.cxx:3235
 AliFlowTrackCuts.cxx:3236
 AliFlowTrackCuts.cxx:3237
 AliFlowTrackCuts.cxx:3238
 AliFlowTrackCuts.cxx:3239
 AliFlowTrackCuts.cxx:3240
 AliFlowTrackCuts.cxx:3241
 AliFlowTrackCuts.cxx:3242
 AliFlowTrackCuts.cxx:3243
 AliFlowTrackCuts.cxx:3244
 AliFlowTrackCuts.cxx:3245
 AliFlowTrackCuts.cxx:3246
 AliFlowTrackCuts.cxx:3247
 AliFlowTrackCuts.cxx:3248
 AliFlowTrackCuts.cxx:3249
 AliFlowTrackCuts.cxx:3250
 AliFlowTrackCuts.cxx:3251
 AliFlowTrackCuts.cxx:3252
 AliFlowTrackCuts.cxx:3253
 AliFlowTrackCuts.cxx:3254
 AliFlowTrackCuts.cxx:3255
 AliFlowTrackCuts.cxx:3256
 AliFlowTrackCuts.cxx:3257
 AliFlowTrackCuts.cxx:3258
 AliFlowTrackCuts.cxx:3259
 AliFlowTrackCuts.cxx:3260
 AliFlowTrackCuts.cxx:3261
 AliFlowTrackCuts.cxx:3262
 AliFlowTrackCuts.cxx:3263
 AliFlowTrackCuts.cxx:3264
 AliFlowTrackCuts.cxx:3265
 AliFlowTrackCuts.cxx:3266
 AliFlowTrackCuts.cxx:3267
 AliFlowTrackCuts.cxx:3268
 AliFlowTrackCuts.cxx:3269
 AliFlowTrackCuts.cxx:3270
 AliFlowTrackCuts.cxx:3271
 AliFlowTrackCuts.cxx:3272
 AliFlowTrackCuts.cxx:3273
 AliFlowTrackCuts.cxx:3274
 AliFlowTrackCuts.cxx:3275
 AliFlowTrackCuts.cxx:3276
 AliFlowTrackCuts.cxx:3277
 AliFlowTrackCuts.cxx:3278
 AliFlowTrackCuts.cxx:3279
 AliFlowTrackCuts.cxx:3280
 AliFlowTrackCuts.cxx:3281
 AliFlowTrackCuts.cxx:3282
 AliFlowTrackCuts.cxx:3283
 AliFlowTrackCuts.cxx:3284
 AliFlowTrackCuts.cxx:3285
 AliFlowTrackCuts.cxx:3286
 AliFlowTrackCuts.cxx:3287
 AliFlowTrackCuts.cxx:3288
 AliFlowTrackCuts.cxx:3289
 AliFlowTrackCuts.cxx:3290
 AliFlowTrackCuts.cxx:3291
 AliFlowTrackCuts.cxx:3292
 AliFlowTrackCuts.cxx:3293
 AliFlowTrackCuts.cxx:3294
 AliFlowTrackCuts.cxx:3295
 AliFlowTrackCuts.cxx:3296
 AliFlowTrackCuts.cxx:3297
 AliFlowTrackCuts.cxx:3298
 AliFlowTrackCuts.cxx:3299
 AliFlowTrackCuts.cxx:3300
 AliFlowTrackCuts.cxx:3301
 AliFlowTrackCuts.cxx:3302
 AliFlowTrackCuts.cxx:3303
 AliFlowTrackCuts.cxx:3304
 AliFlowTrackCuts.cxx:3305
 AliFlowTrackCuts.cxx:3306
 AliFlowTrackCuts.cxx:3307
 AliFlowTrackCuts.cxx:3308
 AliFlowTrackCuts.cxx:3309
 AliFlowTrackCuts.cxx:3310
 AliFlowTrackCuts.cxx:3311
 AliFlowTrackCuts.cxx:3312
 AliFlowTrackCuts.cxx:3313
 AliFlowTrackCuts.cxx:3314
 AliFlowTrackCuts.cxx:3315
 AliFlowTrackCuts.cxx:3316
 AliFlowTrackCuts.cxx:3317
 AliFlowTrackCuts.cxx:3318
 AliFlowTrackCuts.cxx:3319
 AliFlowTrackCuts.cxx:3320
 AliFlowTrackCuts.cxx:3321
 AliFlowTrackCuts.cxx:3322
 AliFlowTrackCuts.cxx:3323
 AliFlowTrackCuts.cxx:3324
 AliFlowTrackCuts.cxx:3325
 AliFlowTrackCuts.cxx:3326
 AliFlowTrackCuts.cxx:3327
 AliFlowTrackCuts.cxx:3328
 AliFlowTrackCuts.cxx:3329
 AliFlowTrackCuts.cxx:3330
 AliFlowTrackCuts.cxx:3331
 AliFlowTrackCuts.cxx:3332
 AliFlowTrackCuts.cxx:3333
 AliFlowTrackCuts.cxx:3334
 AliFlowTrackCuts.cxx:3335
 AliFlowTrackCuts.cxx:3336
 AliFlowTrackCuts.cxx:3337
 AliFlowTrackCuts.cxx:3338
 AliFlowTrackCuts.cxx:3339
 AliFlowTrackCuts.cxx:3340
 AliFlowTrackCuts.cxx:3341
 AliFlowTrackCuts.cxx:3342
 AliFlowTrackCuts.cxx:3343
 AliFlowTrackCuts.cxx:3344
 AliFlowTrackCuts.cxx:3345
 AliFlowTrackCuts.cxx:3346
 AliFlowTrackCuts.cxx:3347
 AliFlowTrackCuts.cxx:3348
 AliFlowTrackCuts.cxx:3349
 AliFlowTrackCuts.cxx:3350
 AliFlowTrackCuts.cxx:3351
 AliFlowTrackCuts.cxx:3352
 AliFlowTrackCuts.cxx:3353
 AliFlowTrackCuts.cxx:3354
 AliFlowTrackCuts.cxx:3355
 AliFlowTrackCuts.cxx:3356
 AliFlowTrackCuts.cxx:3357
 AliFlowTrackCuts.cxx:3358
 AliFlowTrackCuts.cxx:3359
 AliFlowTrackCuts.cxx:3360
 AliFlowTrackCuts.cxx:3361
 AliFlowTrackCuts.cxx:3362
 AliFlowTrackCuts.cxx:3363
 AliFlowTrackCuts.cxx:3364
 AliFlowTrackCuts.cxx:3365
 AliFlowTrackCuts.cxx:3366
 AliFlowTrackCuts.cxx:3367
 AliFlowTrackCuts.cxx:3368
 AliFlowTrackCuts.cxx:3369
 AliFlowTrackCuts.cxx:3370
 AliFlowTrackCuts.cxx:3371
 AliFlowTrackCuts.cxx:3372
 AliFlowTrackCuts.cxx:3373
 AliFlowTrackCuts.cxx:3374
 AliFlowTrackCuts.cxx:3375
 AliFlowTrackCuts.cxx:3376
 AliFlowTrackCuts.cxx:3377
 AliFlowTrackCuts.cxx:3378
 AliFlowTrackCuts.cxx:3379
 AliFlowTrackCuts.cxx:3380
 AliFlowTrackCuts.cxx:3381
 AliFlowTrackCuts.cxx:3382
 AliFlowTrackCuts.cxx:3383
 AliFlowTrackCuts.cxx:3384
 AliFlowTrackCuts.cxx:3385
 AliFlowTrackCuts.cxx:3386
 AliFlowTrackCuts.cxx:3387
 AliFlowTrackCuts.cxx:3388
 AliFlowTrackCuts.cxx:3389
 AliFlowTrackCuts.cxx:3390
 AliFlowTrackCuts.cxx:3391
 AliFlowTrackCuts.cxx:3392
 AliFlowTrackCuts.cxx:3393
 AliFlowTrackCuts.cxx:3394
 AliFlowTrackCuts.cxx:3395
 AliFlowTrackCuts.cxx:3396
 AliFlowTrackCuts.cxx:3397
 AliFlowTrackCuts.cxx:3398
 AliFlowTrackCuts.cxx:3399
 AliFlowTrackCuts.cxx:3400
 AliFlowTrackCuts.cxx:3401
 AliFlowTrackCuts.cxx:3402
 AliFlowTrackCuts.cxx:3403
 AliFlowTrackCuts.cxx:3404
 AliFlowTrackCuts.cxx:3405
 AliFlowTrackCuts.cxx:3406
 AliFlowTrackCuts.cxx:3407
 AliFlowTrackCuts.cxx:3408
 AliFlowTrackCuts.cxx:3409
 AliFlowTrackCuts.cxx:3410
 AliFlowTrackCuts.cxx:3411
 AliFlowTrackCuts.cxx:3412
 AliFlowTrackCuts.cxx:3413
 AliFlowTrackCuts.cxx:3414
 AliFlowTrackCuts.cxx:3415
 AliFlowTrackCuts.cxx:3416
 AliFlowTrackCuts.cxx:3417
 AliFlowTrackCuts.cxx:3418
 AliFlowTrackCuts.cxx:3419
 AliFlowTrackCuts.cxx:3420
 AliFlowTrackCuts.cxx:3421
 AliFlowTrackCuts.cxx:3422
 AliFlowTrackCuts.cxx:3423
 AliFlowTrackCuts.cxx:3424
 AliFlowTrackCuts.cxx:3425
 AliFlowTrackCuts.cxx:3426
 AliFlowTrackCuts.cxx:3427
 AliFlowTrackCuts.cxx:3428
 AliFlowTrackCuts.cxx:3429
 AliFlowTrackCuts.cxx:3430
 AliFlowTrackCuts.cxx:3431
 AliFlowTrackCuts.cxx:3432
 AliFlowTrackCuts.cxx:3433
 AliFlowTrackCuts.cxx:3434
 AliFlowTrackCuts.cxx:3435
 AliFlowTrackCuts.cxx:3436
 AliFlowTrackCuts.cxx:3437
 AliFlowTrackCuts.cxx:3438
 AliFlowTrackCuts.cxx:3439
 AliFlowTrackCuts.cxx:3440
 AliFlowTrackCuts.cxx:3441
 AliFlowTrackCuts.cxx:3442
 AliFlowTrackCuts.cxx:3443
 AliFlowTrackCuts.cxx:3444
 AliFlowTrackCuts.cxx:3445
 AliFlowTrackCuts.cxx:3446
 AliFlowTrackCuts.cxx:3447
 AliFlowTrackCuts.cxx:3448
 AliFlowTrackCuts.cxx:3449
 AliFlowTrackCuts.cxx:3450
 AliFlowTrackCuts.cxx:3451
 AliFlowTrackCuts.cxx:3452
 AliFlowTrackCuts.cxx:3453
 AliFlowTrackCuts.cxx:3454
 AliFlowTrackCuts.cxx:3455
 AliFlowTrackCuts.cxx:3456
 AliFlowTrackCuts.cxx:3457
 AliFlowTrackCuts.cxx:3458
 AliFlowTrackCuts.cxx:3459
 AliFlowTrackCuts.cxx:3460
 AliFlowTrackCuts.cxx:3461
 AliFlowTrackCuts.cxx:3462
 AliFlowTrackCuts.cxx:3463
 AliFlowTrackCuts.cxx:3464
 AliFlowTrackCuts.cxx:3465
 AliFlowTrackCuts.cxx:3466
 AliFlowTrackCuts.cxx:3467
 AliFlowTrackCuts.cxx:3468
 AliFlowTrackCuts.cxx:3469
 AliFlowTrackCuts.cxx:3470
 AliFlowTrackCuts.cxx:3471
 AliFlowTrackCuts.cxx:3472
 AliFlowTrackCuts.cxx:3473
 AliFlowTrackCuts.cxx:3474
 AliFlowTrackCuts.cxx:3475
 AliFlowTrackCuts.cxx:3476
 AliFlowTrackCuts.cxx:3477
 AliFlowTrackCuts.cxx:3478
 AliFlowTrackCuts.cxx:3479
 AliFlowTrackCuts.cxx:3480
 AliFlowTrackCuts.cxx:3481
 AliFlowTrackCuts.cxx:3482
 AliFlowTrackCuts.cxx:3483
 AliFlowTrackCuts.cxx:3484
 AliFlowTrackCuts.cxx:3485
 AliFlowTrackCuts.cxx:3486
 AliFlowTrackCuts.cxx:3487
 AliFlowTrackCuts.cxx:3488
 AliFlowTrackCuts.cxx:3489
 AliFlowTrackCuts.cxx:3490
 AliFlowTrackCuts.cxx:3491
 AliFlowTrackCuts.cxx:3492
 AliFlowTrackCuts.cxx:3493
 AliFlowTrackCuts.cxx:3494
 AliFlowTrackCuts.cxx:3495
 AliFlowTrackCuts.cxx:3496
 AliFlowTrackCuts.cxx:3497
 AliFlowTrackCuts.cxx:3498
 AliFlowTrackCuts.cxx:3499
 AliFlowTrackCuts.cxx:3500
 AliFlowTrackCuts.cxx:3501
 AliFlowTrackCuts.cxx:3502
 AliFlowTrackCuts.cxx:3503
 AliFlowTrackCuts.cxx:3504
 AliFlowTrackCuts.cxx:3505
 AliFlowTrackCuts.cxx:3506
 AliFlowTrackCuts.cxx:3507
 AliFlowTrackCuts.cxx:3508
 AliFlowTrackCuts.cxx:3509
 AliFlowTrackCuts.cxx:3510
 AliFlowTrackCuts.cxx:3511
 AliFlowTrackCuts.cxx:3512
 AliFlowTrackCuts.cxx:3513
 AliFlowTrackCuts.cxx:3514
 AliFlowTrackCuts.cxx:3515
 AliFlowTrackCuts.cxx:3516
 AliFlowTrackCuts.cxx:3517
 AliFlowTrackCuts.cxx:3518
 AliFlowTrackCuts.cxx:3519
 AliFlowTrackCuts.cxx:3520
 AliFlowTrackCuts.cxx:3521
 AliFlowTrackCuts.cxx:3522
 AliFlowTrackCuts.cxx:3523
 AliFlowTrackCuts.cxx:3524
 AliFlowTrackCuts.cxx:3525
 AliFlowTrackCuts.cxx:3526
 AliFlowTrackCuts.cxx:3527
 AliFlowTrackCuts.cxx:3528
 AliFlowTrackCuts.cxx:3529
 AliFlowTrackCuts.cxx:3530
 AliFlowTrackCuts.cxx:3531
 AliFlowTrackCuts.cxx:3532
 AliFlowTrackCuts.cxx:3533
 AliFlowTrackCuts.cxx:3534
 AliFlowTrackCuts.cxx:3535
 AliFlowTrackCuts.cxx:3536
 AliFlowTrackCuts.cxx:3537
 AliFlowTrackCuts.cxx:3538
 AliFlowTrackCuts.cxx:3539
 AliFlowTrackCuts.cxx:3540
 AliFlowTrackCuts.cxx:3541
 AliFlowTrackCuts.cxx:3542
 AliFlowTrackCuts.cxx:3543
 AliFlowTrackCuts.cxx:3544
 AliFlowTrackCuts.cxx:3545
 AliFlowTrackCuts.cxx:3546
 AliFlowTrackCuts.cxx:3547
 AliFlowTrackCuts.cxx:3548
 AliFlowTrackCuts.cxx:3549
 AliFlowTrackCuts.cxx:3550
 AliFlowTrackCuts.cxx:3551
 AliFlowTrackCuts.cxx:3552
 AliFlowTrackCuts.cxx:3553
 AliFlowTrackCuts.cxx:3554
 AliFlowTrackCuts.cxx:3555
 AliFlowTrackCuts.cxx:3556
 AliFlowTrackCuts.cxx:3557
 AliFlowTrackCuts.cxx:3558
 AliFlowTrackCuts.cxx:3559
 AliFlowTrackCuts.cxx:3560
 AliFlowTrackCuts.cxx:3561
 AliFlowTrackCuts.cxx:3562
 AliFlowTrackCuts.cxx:3563
 AliFlowTrackCuts.cxx:3564
 AliFlowTrackCuts.cxx:3565
 AliFlowTrackCuts.cxx:3566
 AliFlowTrackCuts.cxx:3567
 AliFlowTrackCuts.cxx:3568
 AliFlowTrackCuts.cxx:3569
 AliFlowTrackCuts.cxx:3570
 AliFlowTrackCuts.cxx:3571
 AliFlowTrackCuts.cxx:3572
 AliFlowTrackCuts.cxx:3573
 AliFlowTrackCuts.cxx:3574
 AliFlowTrackCuts.cxx:3575
 AliFlowTrackCuts.cxx:3576
 AliFlowTrackCuts.cxx:3577
 AliFlowTrackCuts.cxx:3578
 AliFlowTrackCuts.cxx:3579
 AliFlowTrackCuts.cxx:3580
 AliFlowTrackCuts.cxx:3581
 AliFlowTrackCuts.cxx:3582
 AliFlowTrackCuts.cxx:3583
 AliFlowTrackCuts.cxx:3584
 AliFlowTrackCuts.cxx:3585
 AliFlowTrackCuts.cxx:3586
 AliFlowTrackCuts.cxx:3587
 AliFlowTrackCuts.cxx:3588
 AliFlowTrackCuts.cxx:3589
 AliFlowTrackCuts.cxx:3590
 AliFlowTrackCuts.cxx:3591
 AliFlowTrackCuts.cxx:3592
 AliFlowTrackCuts.cxx:3593
 AliFlowTrackCuts.cxx:3594
 AliFlowTrackCuts.cxx:3595
 AliFlowTrackCuts.cxx:3596
 AliFlowTrackCuts.cxx:3597
 AliFlowTrackCuts.cxx:3598
 AliFlowTrackCuts.cxx:3599
 AliFlowTrackCuts.cxx:3600
 AliFlowTrackCuts.cxx:3601
 AliFlowTrackCuts.cxx:3602
 AliFlowTrackCuts.cxx:3603
 AliFlowTrackCuts.cxx:3604
 AliFlowTrackCuts.cxx:3605
 AliFlowTrackCuts.cxx:3606
 AliFlowTrackCuts.cxx:3607
 AliFlowTrackCuts.cxx:3608
 AliFlowTrackCuts.cxx:3609
 AliFlowTrackCuts.cxx:3610
 AliFlowTrackCuts.cxx:3611
 AliFlowTrackCuts.cxx:3612
 AliFlowTrackCuts.cxx:3613
 AliFlowTrackCuts.cxx:3614
 AliFlowTrackCuts.cxx:3615
 AliFlowTrackCuts.cxx:3616
 AliFlowTrackCuts.cxx:3617
 AliFlowTrackCuts.cxx:3618
 AliFlowTrackCuts.cxx:3619
 AliFlowTrackCuts.cxx:3620
 AliFlowTrackCuts.cxx:3621
 AliFlowTrackCuts.cxx:3622
 AliFlowTrackCuts.cxx:3623
 AliFlowTrackCuts.cxx:3624
 AliFlowTrackCuts.cxx:3625
 AliFlowTrackCuts.cxx:3626
 AliFlowTrackCuts.cxx:3627
 AliFlowTrackCuts.cxx:3628
 AliFlowTrackCuts.cxx:3629
 AliFlowTrackCuts.cxx:3630
 AliFlowTrackCuts.cxx:3631
 AliFlowTrackCuts.cxx:3632
 AliFlowTrackCuts.cxx:3633
 AliFlowTrackCuts.cxx:3634
 AliFlowTrackCuts.cxx:3635
 AliFlowTrackCuts.cxx:3636
 AliFlowTrackCuts.cxx:3637
 AliFlowTrackCuts.cxx:3638
 AliFlowTrackCuts.cxx:3639
 AliFlowTrackCuts.cxx:3640
 AliFlowTrackCuts.cxx:3641
 AliFlowTrackCuts.cxx:3642
 AliFlowTrackCuts.cxx:3643
 AliFlowTrackCuts.cxx:3644
 AliFlowTrackCuts.cxx:3645
 AliFlowTrackCuts.cxx:3646
 AliFlowTrackCuts.cxx:3647
 AliFlowTrackCuts.cxx:3648
 AliFlowTrackCuts.cxx:3649
 AliFlowTrackCuts.cxx:3650
 AliFlowTrackCuts.cxx:3651
 AliFlowTrackCuts.cxx:3652
 AliFlowTrackCuts.cxx:3653
 AliFlowTrackCuts.cxx:3654
 AliFlowTrackCuts.cxx:3655
 AliFlowTrackCuts.cxx:3656
 AliFlowTrackCuts.cxx:3657
 AliFlowTrackCuts.cxx:3658
 AliFlowTrackCuts.cxx:3659
 AliFlowTrackCuts.cxx:3660
 AliFlowTrackCuts.cxx:3661
 AliFlowTrackCuts.cxx:3662
 AliFlowTrackCuts.cxx:3663
 AliFlowTrackCuts.cxx:3664
 AliFlowTrackCuts.cxx:3665
 AliFlowTrackCuts.cxx:3666
 AliFlowTrackCuts.cxx:3667
 AliFlowTrackCuts.cxx:3668
 AliFlowTrackCuts.cxx:3669
 AliFlowTrackCuts.cxx:3670
 AliFlowTrackCuts.cxx:3671
 AliFlowTrackCuts.cxx:3672
 AliFlowTrackCuts.cxx:3673
 AliFlowTrackCuts.cxx:3674
 AliFlowTrackCuts.cxx:3675
 AliFlowTrackCuts.cxx:3676
 AliFlowTrackCuts.cxx:3677
 AliFlowTrackCuts.cxx:3678
 AliFlowTrackCuts.cxx:3679
 AliFlowTrackCuts.cxx:3680
 AliFlowTrackCuts.cxx:3681
 AliFlowTrackCuts.cxx:3682
 AliFlowTrackCuts.cxx:3683
 AliFlowTrackCuts.cxx:3684
 AliFlowTrackCuts.cxx:3685
 AliFlowTrackCuts.cxx:3686
 AliFlowTrackCuts.cxx:3687
 AliFlowTrackCuts.cxx:3688
 AliFlowTrackCuts.cxx:3689
 AliFlowTrackCuts.cxx:3690
 AliFlowTrackCuts.cxx:3691
 AliFlowTrackCuts.cxx:3692
 AliFlowTrackCuts.cxx:3693
 AliFlowTrackCuts.cxx:3694
 AliFlowTrackCuts.cxx:3695
 AliFlowTrackCuts.cxx:3696
 AliFlowTrackCuts.cxx:3697
 AliFlowTrackCuts.cxx:3698
 AliFlowTrackCuts.cxx:3699
 AliFlowTrackCuts.cxx:3700
 AliFlowTrackCuts.cxx:3701
 AliFlowTrackCuts.cxx:3702
 AliFlowTrackCuts.cxx:3703
 AliFlowTrackCuts.cxx:3704
 AliFlowTrackCuts.cxx:3705
 AliFlowTrackCuts.cxx:3706
 AliFlowTrackCuts.cxx:3707
 AliFlowTrackCuts.cxx:3708
 AliFlowTrackCuts.cxx:3709
 AliFlowTrackCuts.cxx:3710
 AliFlowTrackCuts.cxx:3711
 AliFlowTrackCuts.cxx:3712
 AliFlowTrackCuts.cxx:3713
 AliFlowTrackCuts.cxx:3714
 AliFlowTrackCuts.cxx:3715
 AliFlowTrackCuts.cxx:3716
 AliFlowTrackCuts.cxx:3717
 AliFlowTrackCuts.cxx:3718
 AliFlowTrackCuts.cxx:3719
 AliFlowTrackCuts.cxx:3720
 AliFlowTrackCuts.cxx:3721
 AliFlowTrackCuts.cxx:3722
 AliFlowTrackCuts.cxx:3723
 AliFlowTrackCuts.cxx:3724
 AliFlowTrackCuts.cxx:3725
 AliFlowTrackCuts.cxx:3726
 AliFlowTrackCuts.cxx:3727
 AliFlowTrackCuts.cxx:3728
 AliFlowTrackCuts.cxx:3729
 AliFlowTrackCuts.cxx:3730
 AliFlowTrackCuts.cxx:3731
 AliFlowTrackCuts.cxx:3732
 AliFlowTrackCuts.cxx:3733
 AliFlowTrackCuts.cxx:3734
 AliFlowTrackCuts.cxx:3735
 AliFlowTrackCuts.cxx:3736
 AliFlowTrackCuts.cxx:3737
 AliFlowTrackCuts.cxx:3738
 AliFlowTrackCuts.cxx:3739
 AliFlowTrackCuts.cxx:3740
 AliFlowTrackCuts.cxx:3741
 AliFlowTrackCuts.cxx:3742
 AliFlowTrackCuts.cxx:3743
 AliFlowTrackCuts.cxx:3744
 AliFlowTrackCuts.cxx:3745
 AliFlowTrackCuts.cxx:3746
 AliFlowTrackCuts.cxx:3747
 AliFlowTrackCuts.cxx:3748
 AliFlowTrackCuts.cxx:3749
 AliFlowTrackCuts.cxx:3750
 AliFlowTrackCuts.cxx:3751
 AliFlowTrackCuts.cxx:3752
 AliFlowTrackCuts.cxx:3753
 AliFlowTrackCuts.cxx:3754
 AliFlowTrackCuts.cxx:3755
 AliFlowTrackCuts.cxx:3756
 AliFlowTrackCuts.cxx:3757
 AliFlowTrackCuts.cxx:3758
 AliFlowTrackCuts.cxx:3759
 AliFlowTrackCuts.cxx:3760
 AliFlowTrackCuts.cxx:3761
 AliFlowTrackCuts.cxx:3762
 AliFlowTrackCuts.cxx:3763
 AliFlowTrackCuts.cxx:3764
 AliFlowTrackCuts.cxx:3765
 AliFlowTrackCuts.cxx:3766
 AliFlowTrackCuts.cxx:3767
 AliFlowTrackCuts.cxx:3768
 AliFlowTrackCuts.cxx:3769
 AliFlowTrackCuts.cxx:3770
 AliFlowTrackCuts.cxx:3771
 AliFlowTrackCuts.cxx:3772
 AliFlowTrackCuts.cxx:3773
 AliFlowTrackCuts.cxx:3774
 AliFlowTrackCuts.cxx:3775
 AliFlowTrackCuts.cxx:3776
 AliFlowTrackCuts.cxx:3777
 AliFlowTrackCuts.cxx:3778
 AliFlowTrackCuts.cxx:3779
 AliFlowTrackCuts.cxx:3780
 AliFlowTrackCuts.cxx:3781
 AliFlowTrackCuts.cxx:3782
 AliFlowTrackCuts.cxx:3783
 AliFlowTrackCuts.cxx:3784
 AliFlowTrackCuts.cxx:3785
 AliFlowTrackCuts.cxx:3786
 AliFlowTrackCuts.cxx:3787
 AliFlowTrackCuts.cxx:3788
 AliFlowTrackCuts.cxx:3789
 AliFlowTrackCuts.cxx:3790
 AliFlowTrackCuts.cxx:3791
 AliFlowTrackCuts.cxx:3792
 AliFlowTrackCuts.cxx:3793
 AliFlowTrackCuts.cxx:3794
 AliFlowTrackCuts.cxx:3795
 AliFlowTrackCuts.cxx:3796
 AliFlowTrackCuts.cxx:3797
 AliFlowTrackCuts.cxx:3798
 AliFlowTrackCuts.cxx:3799
 AliFlowTrackCuts.cxx:3800
 AliFlowTrackCuts.cxx:3801
 AliFlowTrackCuts.cxx:3802
 AliFlowTrackCuts.cxx:3803
 AliFlowTrackCuts.cxx:3804
 AliFlowTrackCuts.cxx:3805
 AliFlowTrackCuts.cxx:3806
 AliFlowTrackCuts.cxx:3807
 AliFlowTrackCuts.cxx:3808
 AliFlowTrackCuts.cxx:3809
 AliFlowTrackCuts.cxx:3810
 AliFlowTrackCuts.cxx:3811
 AliFlowTrackCuts.cxx:3812
 AliFlowTrackCuts.cxx:3813
 AliFlowTrackCuts.cxx:3814
 AliFlowTrackCuts.cxx:3815
 AliFlowTrackCuts.cxx:3816
 AliFlowTrackCuts.cxx:3817
 AliFlowTrackCuts.cxx:3818
 AliFlowTrackCuts.cxx:3819
 AliFlowTrackCuts.cxx:3820
 AliFlowTrackCuts.cxx:3821
 AliFlowTrackCuts.cxx:3822
 AliFlowTrackCuts.cxx:3823
 AliFlowTrackCuts.cxx:3824
 AliFlowTrackCuts.cxx:3825
 AliFlowTrackCuts.cxx:3826
 AliFlowTrackCuts.cxx:3827
 AliFlowTrackCuts.cxx:3828
 AliFlowTrackCuts.cxx:3829
 AliFlowTrackCuts.cxx:3830
 AliFlowTrackCuts.cxx:3831
 AliFlowTrackCuts.cxx:3832
 AliFlowTrackCuts.cxx:3833
 AliFlowTrackCuts.cxx:3834
 AliFlowTrackCuts.cxx:3835
 AliFlowTrackCuts.cxx:3836
 AliFlowTrackCuts.cxx:3837
 AliFlowTrackCuts.cxx:3838
 AliFlowTrackCuts.cxx:3839
 AliFlowTrackCuts.cxx:3840
 AliFlowTrackCuts.cxx:3841
 AliFlowTrackCuts.cxx:3842
 AliFlowTrackCuts.cxx:3843
 AliFlowTrackCuts.cxx:3844
 AliFlowTrackCuts.cxx:3845
 AliFlowTrackCuts.cxx:3846
 AliFlowTrackCuts.cxx:3847
 AliFlowTrackCuts.cxx:3848
 AliFlowTrackCuts.cxx:3849
 AliFlowTrackCuts.cxx:3850
 AliFlowTrackCuts.cxx:3851
 AliFlowTrackCuts.cxx:3852
 AliFlowTrackCuts.cxx:3853
 AliFlowTrackCuts.cxx:3854
 AliFlowTrackCuts.cxx:3855
 AliFlowTrackCuts.cxx:3856
 AliFlowTrackCuts.cxx:3857
 AliFlowTrackCuts.cxx:3858
 AliFlowTrackCuts.cxx:3859
 AliFlowTrackCuts.cxx:3860
 AliFlowTrackCuts.cxx:3861
 AliFlowTrackCuts.cxx:3862
 AliFlowTrackCuts.cxx:3863
 AliFlowTrackCuts.cxx:3864
 AliFlowTrackCuts.cxx:3865
 AliFlowTrackCuts.cxx:3866
 AliFlowTrackCuts.cxx:3867
 AliFlowTrackCuts.cxx:3868
 AliFlowTrackCuts.cxx:3869
 AliFlowTrackCuts.cxx:3870
 AliFlowTrackCuts.cxx:3871
 AliFlowTrackCuts.cxx:3872
 AliFlowTrackCuts.cxx:3873
 AliFlowTrackCuts.cxx:3874
 AliFlowTrackCuts.cxx:3875
 AliFlowTrackCuts.cxx:3876
 AliFlowTrackCuts.cxx:3877
 AliFlowTrackCuts.cxx:3878
 AliFlowTrackCuts.cxx:3879
 AliFlowTrackCuts.cxx:3880
 AliFlowTrackCuts.cxx:3881
 AliFlowTrackCuts.cxx:3882
 AliFlowTrackCuts.cxx:3883
 AliFlowTrackCuts.cxx:3884
 AliFlowTrackCuts.cxx:3885
 AliFlowTrackCuts.cxx:3886
 AliFlowTrackCuts.cxx:3887
 AliFlowTrackCuts.cxx:3888
 AliFlowTrackCuts.cxx:3889
 AliFlowTrackCuts.cxx:3890
 AliFlowTrackCuts.cxx:3891
 AliFlowTrackCuts.cxx:3892
 AliFlowTrackCuts.cxx:3893
 AliFlowTrackCuts.cxx:3894
 AliFlowTrackCuts.cxx:3895
 AliFlowTrackCuts.cxx:3896
 AliFlowTrackCuts.cxx:3897
 AliFlowTrackCuts.cxx:3898
 AliFlowTrackCuts.cxx:3899
 AliFlowTrackCuts.cxx:3900
 AliFlowTrackCuts.cxx:3901
 AliFlowTrackCuts.cxx:3902
 AliFlowTrackCuts.cxx:3903
 AliFlowTrackCuts.cxx:3904
 AliFlowTrackCuts.cxx:3905
 AliFlowTrackCuts.cxx:3906
 AliFlowTrackCuts.cxx:3907
 AliFlowTrackCuts.cxx:3908
 AliFlowTrackCuts.cxx:3909
 AliFlowTrackCuts.cxx:3910
 AliFlowTrackCuts.cxx:3911
 AliFlowTrackCuts.cxx:3912
 AliFlowTrackCuts.cxx:3913
 AliFlowTrackCuts.cxx:3914
 AliFlowTrackCuts.cxx:3915
 AliFlowTrackCuts.cxx:3916
 AliFlowTrackCuts.cxx:3917
 AliFlowTrackCuts.cxx:3918
 AliFlowTrackCuts.cxx:3919
 AliFlowTrackCuts.cxx:3920
 AliFlowTrackCuts.cxx:3921
 AliFlowTrackCuts.cxx:3922
 AliFlowTrackCuts.cxx:3923
 AliFlowTrackCuts.cxx:3924
 AliFlowTrackCuts.cxx:3925
 AliFlowTrackCuts.cxx:3926
 AliFlowTrackCuts.cxx:3927
 AliFlowTrackCuts.cxx:3928
 AliFlowTrackCuts.cxx:3929
 AliFlowTrackCuts.cxx:3930
 AliFlowTrackCuts.cxx:3931
 AliFlowTrackCuts.cxx:3932
 AliFlowTrackCuts.cxx:3933
 AliFlowTrackCuts.cxx:3934
 AliFlowTrackCuts.cxx:3935
 AliFlowTrackCuts.cxx:3936
 AliFlowTrackCuts.cxx:3937
 AliFlowTrackCuts.cxx:3938
 AliFlowTrackCuts.cxx:3939
 AliFlowTrackCuts.cxx:3940
 AliFlowTrackCuts.cxx:3941
 AliFlowTrackCuts.cxx:3942
 AliFlowTrackCuts.cxx:3943
 AliFlowTrackCuts.cxx:3944
 AliFlowTrackCuts.cxx:3945
 AliFlowTrackCuts.cxx:3946
 AliFlowTrackCuts.cxx:3947
 AliFlowTrackCuts.cxx:3948
 AliFlowTrackCuts.cxx:3949
 AliFlowTrackCuts.cxx:3950
 AliFlowTrackCuts.cxx:3951
 AliFlowTrackCuts.cxx:3952
 AliFlowTrackCuts.cxx:3953
 AliFlowTrackCuts.cxx:3954
 AliFlowTrackCuts.cxx:3955
 AliFlowTrackCuts.cxx:3956
 AliFlowTrackCuts.cxx:3957
 AliFlowTrackCuts.cxx:3958
 AliFlowTrackCuts.cxx:3959
 AliFlowTrackCuts.cxx:3960
 AliFlowTrackCuts.cxx:3961
 AliFlowTrackCuts.cxx:3962
 AliFlowTrackCuts.cxx:3963
 AliFlowTrackCuts.cxx:3964
 AliFlowTrackCuts.cxx:3965
 AliFlowTrackCuts.cxx:3966
 AliFlowTrackCuts.cxx:3967
 AliFlowTrackCuts.cxx:3968
 AliFlowTrackCuts.cxx:3969
 AliFlowTrackCuts.cxx:3970
 AliFlowTrackCuts.cxx:3971
 AliFlowTrackCuts.cxx:3972
 AliFlowTrackCuts.cxx:3973
 AliFlowTrackCuts.cxx:3974
 AliFlowTrackCuts.cxx:3975
 AliFlowTrackCuts.cxx:3976
 AliFlowTrackCuts.cxx:3977
 AliFlowTrackCuts.cxx:3978
 AliFlowTrackCuts.cxx:3979
 AliFlowTrackCuts.cxx:3980
 AliFlowTrackCuts.cxx:3981
 AliFlowTrackCuts.cxx:3982
 AliFlowTrackCuts.cxx:3983
 AliFlowTrackCuts.cxx:3984
 AliFlowTrackCuts.cxx:3985
 AliFlowTrackCuts.cxx:3986
 AliFlowTrackCuts.cxx:3987
 AliFlowTrackCuts.cxx:3988
 AliFlowTrackCuts.cxx:3989
 AliFlowTrackCuts.cxx:3990
 AliFlowTrackCuts.cxx:3991
 AliFlowTrackCuts.cxx:3992
 AliFlowTrackCuts.cxx:3993
 AliFlowTrackCuts.cxx:3994
 AliFlowTrackCuts.cxx:3995
 AliFlowTrackCuts.cxx:3996
 AliFlowTrackCuts.cxx:3997
 AliFlowTrackCuts.cxx:3998
 AliFlowTrackCuts.cxx:3999
 AliFlowTrackCuts.cxx:4000
 AliFlowTrackCuts.cxx:4001
 AliFlowTrackCuts.cxx:4002
 AliFlowTrackCuts.cxx:4003
 AliFlowTrackCuts.cxx:4004
 AliFlowTrackCuts.cxx:4005
 AliFlowTrackCuts.cxx:4006
 AliFlowTrackCuts.cxx:4007
 AliFlowTrackCuts.cxx:4008
 AliFlowTrackCuts.cxx:4009
 AliFlowTrackCuts.cxx:4010
 AliFlowTrackCuts.cxx:4011
 AliFlowTrackCuts.cxx:4012
 AliFlowTrackCuts.cxx:4013
 AliFlowTrackCuts.cxx:4014
 AliFlowTrackCuts.cxx:4015
 AliFlowTrackCuts.cxx:4016
 AliFlowTrackCuts.cxx:4017
 AliFlowTrackCuts.cxx:4018
 AliFlowTrackCuts.cxx:4019
 AliFlowTrackCuts.cxx:4020
 AliFlowTrackCuts.cxx:4021
 AliFlowTrackCuts.cxx:4022
 AliFlowTrackCuts.cxx:4023
 AliFlowTrackCuts.cxx:4024
 AliFlowTrackCuts.cxx:4025
 AliFlowTrackCuts.cxx:4026
 AliFlowTrackCuts.cxx:4027
 AliFlowTrackCuts.cxx:4028
 AliFlowTrackCuts.cxx:4029
 AliFlowTrackCuts.cxx:4030
 AliFlowTrackCuts.cxx:4031
 AliFlowTrackCuts.cxx:4032
 AliFlowTrackCuts.cxx:4033
 AliFlowTrackCuts.cxx:4034
 AliFlowTrackCuts.cxx:4035
 AliFlowTrackCuts.cxx:4036
 AliFlowTrackCuts.cxx:4037
 AliFlowTrackCuts.cxx:4038
 AliFlowTrackCuts.cxx:4039
 AliFlowTrackCuts.cxx:4040
 AliFlowTrackCuts.cxx:4041
 AliFlowTrackCuts.cxx:4042
 AliFlowTrackCuts.cxx:4043
 AliFlowTrackCuts.cxx:4044
 AliFlowTrackCuts.cxx:4045
 AliFlowTrackCuts.cxx:4046
 AliFlowTrackCuts.cxx:4047
 AliFlowTrackCuts.cxx:4048
 AliFlowTrackCuts.cxx:4049
 AliFlowTrackCuts.cxx:4050
 AliFlowTrackCuts.cxx:4051
 AliFlowTrackCuts.cxx:4052
 AliFlowTrackCuts.cxx:4053
 AliFlowTrackCuts.cxx:4054
 AliFlowTrackCuts.cxx:4055
 AliFlowTrackCuts.cxx:4056
 AliFlowTrackCuts.cxx:4057
 AliFlowTrackCuts.cxx:4058
 AliFlowTrackCuts.cxx:4059
 AliFlowTrackCuts.cxx:4060
 AliFlowTrackCuts.cxx:4061
 AliFlowTrackCuts.cxx:4062
 AliFlowTrackCuts.cxx:4063
 AliFlowTrackCuts.cxx:4064
 AliFlowTrackCuts.cxx:4065
 AliFlowTrackCuts.cxx:4066
 AliFlowTrackCuts.cxx:4067
 AliFlowTrackCuts.cxx:4068
 AliFlowTrackCuts.cxx:4069
 AliFlowTrackCuts.cxx:4070
 AliFlowTrackCuts.cxx:4071
 AliFlowTrackCuts.cxx:4072
 AliFlowTrackCuts.cxx:4073
 AliFlowTrackCuts.cxx:4074
 AliFlowTrackCuts.cxx:4075
 AliFlowTrackCuts.cxx:4076
 AliFlowTrackCuts.cxx:4077
 AliFlowTrackCuts.cxx:4078
 AliFlowTrackCuts.cxx:4079
 AliFlowTrackCuts.cxx:4080
 AliFlowTrackCuts.cxx:4081
 AliFlowTrackCuts.cxx:4082
 AliFlowTrackCuts.cxx:4083
 AliFlowTrackCuts.cxx:4084
 AliFlowTrackCuts.cxx:4085
 AliFlowTrackCuts.cxx:4086
 AliFlowTrackCuts.cxx:4087
 AliFlowTrackCuts.cxx:4088
 AliFlowTrackCuts.cxx:4089
 AliFlowTrackCuts.cxx:4090
 AliFlowTrackCuts.cxx:4091
 AliFlowTrackCuts.cxx:4092
 AliFlowTrackCuts.cxx:4093
 AliFlowTrackCuts.cxx:4094
 AliFlowTrackCuts.cxx:4095
 AliFlowTrackCuts.cxx:4096
 AliFlowTrackCuts.cxx:4097
 AliFlowTrackCuts.cxx:4098
 AliFlowTrackCuts.cxx:4099
 AliFlowTrackCuts.cxx:4100
 AliFlowTrackCuts.cxx:4101
 AliFlowTrackCuts.cxx:4102
 AliFlowTrackCuts.cxx:4103
 AliFlowTrackCuts.cxx:4104
 AliFlowTrackCuts.cxx:4105
 AliFlowTrackCuts.cxx:4106
 AliFlowTrackCuts.cxx:4107
 AliFlowTrackCuts.cxx:4108
 AliFlowTrackCuts.cxx:4109
 AliFlowTrackCuts.cxx:4110
 AliFlowTrackCuts.cxx:4111
 AliFlowTrackCuts.cxx:4112
 AliFlowTrackCuts.cxx:4113
 AliFlowTrackCuts.cxx:4114
 AliFlowTrackCuts.cxx:4115
 AliFlowTrackCuts.cxx:4116
 AliFlowTrackCuts.cxx:4117
 AliFlowTrackCuts.cxx:4118
 AliFlowTrackCuts.cxx:4119
 AliFlowTrackCuts.cxx:4120
 AliFlowTrackCuts.cxx:4121
 AliFlowTrackCuts.cxx:4122
 AliFlowTrackCuts.cxx:4123
 AliFlowTrackCuts.cxx:4124
 AliFlowTrackCuts.cxx:4125
 AliFlowTrackCuts.cxx:4126
 AliFlowTrackCuts.cxx:4127
 AliFlowTrackCuts.cxx:4128
 AliFlowTrackCuts.cxx:4129
 AliFlowTrackCuts.cxx:4130
 AliFlowTrackCuts.cxx:4131
 AliFlowTrackCuts.cxx:4132
 AliFlowTrackCuts.cxx:4133
 AliFlowTrackCuts.cxx:4134
 AliFlowTrackCuts.cxx:4135
 AliFlowTrackCuts.cxx:4136
 AliFlowTrackCuts.cxx:4137
 AliFlowTrackCuts.cxx:4138
 AliFlowTrackCuts.cxx:4139
 AliFlowTrackCuts.cxx:4140
 AliFlowTrackCuts.cxx:4141
 AliFlowTrackCuts.cxx:4142
 AliFlowTrackCuts.cxx:4143
 AliFlowTrackCuts.cxx:4144
 AliFlowTrackCuts.cxx:4145
 AliFlowTrackCuts.cxx:4146
 AliFlowTrackCuts.cxx:4147
 AliFlowTrackCuts.cxx:4148
 AliFlowTrackCuts.cxx:4149
 AliFlowTrackCuts.cxx:4150
 AliFlowTrackCuts.cxx:4151
 AliFlowTrackCuts.cxx:4152
 AliFlowTrackCuts.cxx:4153
 AliFlowTrackCuts.cxx:4154
 AliFlowTrackCuts.cxx:4155
 AliFlowTrackCuts.cxx:4156
 AliFlowTrackCuts.cxx:4157
 AliFlowTrackCuts.cxx:4158
 AliFlowTrackCuts.cxx:4159
 AliFlowTrackCuts.cxx:4160
 AliFlowTrackCuts.cxx:4161
 AliFlowTrackCuts.cxx:4162
 AliFlowTrackCuts.cxx:4163
 AliFlowTrackCuts.cxx:4164
 AliFlowTrackCuts.cxx:4165
 AliFlowTrackCuts.cxx:4166
 AliFlowTrackCuts.cxx:4167
 AliFlowTrackCuts.cxx:4168
 AliFlowTrackCuts.cxx:4169
 AliFlowTrackCuts.cxx:4170
 AliFlowTrackCuts.cxx:4171
 AliFlowTrackCuts.cxx:4172
 AliFlowTrackCuts.cxx:4173
 AliFlowTrackCuts.cxx:4174
 AliFlowTrackCuts.cxx:4175
 AliFlowTrackCuts.cxx:4176
 AliFlowTrackCuts.cxx:4177
 AliFlowTrackCuts.cxx:4178
 AliFlowTrackCuts.cxx:4179
 AliFlowTrackCuts.cxx:4180
 AliFlowTrackCuts.cxx:4181
 AliFlowTrackCuts.cxx:4182
 AliFlowTrackCuts.cxx:4183
 AliFlowTrackCuts.cxx:4184
 AliFlowTrackCuts.cxx:4185
 AliFlowTrackCuts.cxx:4186
 AliFlowTrackCuts.cxx:4187
 AliFlowTrackCuts.cxx:4188
 AliFlowTrackCuts.cxx:4189
 AliFlowTrackCuts.cxx:4190
 AliFlowTrackCuts.cxx:4191
 AliFlowTrackCuts.cxx:4192
 AliFlowTrackCuts.cxx:4193
 AliFlowTrackCuts.cxx:4194
 AliFlowTrackCuts.cxx:4195
 AliFlowTrackCuts.cxx:4196
 AliFlowTrackCuts.cxx:4197
 AliFlowTrackCuts.cxx:4198
 AliFlowTrackCuts.cxx:4199
 AliFlowTrackCuts.cxx:4200
 AliFlowTrackCuts.cxx:4201
 AliFlowTrackCuts.cxx:4202
 AliFlowTrackCuts.cxx:4203
 AliFlowTrackCuts.cxx:4204
 AliFlowTrackCuts.cxx:4205
 AliFlowTrackCuts.cxx:4206
 AliFlowTrackCuts.cxx:4207
 AliFlowTrackCuts.cxx:4208
 AliFlowTrackCuts.cxx:4209
 AliFlowTrackCuts.cxx:4210
 AliFlowTrackCuts.cxx:4211
 AliFlowTrackCuts.cxx:4212
 AliFlowTrackCuts.cxx:4213
 AliFlowTrackCuts.cxx:4214
 AliFlowTrackCuts.cxx:4215
 AliFlowTrackCuts.cxx:4216
 AliFlowTrackCuts.cxx:4217
 AliFlowTrackCuts.cxx:4218
 AliFlowTrackCuts.cxx:4219
 AliFlowTrackCuts.cxx:4220
 AliFlowTrackCuts.cxx:4221
 AliFlowTrackCuts.cxx:4222
 AliFlowTrackCuts.cxx:4223
 AliFlowTrackCuts.cxx:4224
 AliFlowTrackCuts.cxx:4225
 AliFlowTrackCuts.cxx:4226
 AliFlowTrackCuts.cxx:4227
 AliFlowTrackCuts.cxx:4228
 AliFlowTrackCuts.cxx:4229
 AliFlowTrackCuts.cxx:4230
 AliFlowTrackCuts.cxx:4231
 AliFlowTrackCuts.cxx:4232
 AliFlowTrackCuts.cxx:4233
 AliFlowTrackCuts.cxx:4234
 AliFlowTrackCuts.cxx:4235
 AliFlowTrackCuts.cxx:4236
 AliFlowTrackCuts.cxx:4237
 AliFlowTrackCuts.cxx:4238
 AliFlowTrackCuts.cxx:4239
 AliFlowTrackCuts.cxx:4240
 AliFlowTrackCuts.cxx:4241
 AliFlowTrackCuts.cxx:4242
 AliFlowTrackCuts.cxx:4243
 AliFlowTrackCuts.cxx:4244
 AliFlowTrackCuts.cxx:4245
 AliFlowTrackCuts.cxx:4246
 AliFlowTrackCuts.cxx:4247
 AliFlowTrackCuts.cxx:4248
 AliFlowTrackCuts.cxx:4249
 AliFlowTrackCuts.cxx:4250
 AliFlowTrackCuts.cxx:4251
 AliFlowTrackCuts.cxx:4252
 AliFlowTrackCuts.cxx:4253
 AliFlowTrackCuts.cxx:4254
 AliFlowTrackCuts.cxx:4255
 AliFlowTrackCuts.cxx:4256
 AliFlowTrackCuts.cxx:4257
 AliFlowTrackCuts.cxx:4258
 AliFlowTrackCuts.cxx:4259
 AliFlowTrackCuts.cxx:4260
 AliFlowTrackCuts.cxx:4261
 AliFlowTrackCuts.cxx:4262
 AliFlowTrackCuts.cxx:4263
 AliFlowTrackCuts.cxx:4264
 AliFlowTrackCuts.cxx:4265
 AliFlowTrackCuts.cxx:4266
 AliFlowTrackCuts.cxx:4267
 AliFlowTrackCuts.cxx:4268
 AliFlowTrackCuts.cxx:4269
 AliFlowTrackCuts.cxx:4270
 AliFlowTrackCuts.cxx:4271
 AliFlowTrackCuts.cxx:4272
 AliFlowTrackCuts.cxx:4273
 AliFlowTrackCuts.cxx:4274
 AliFlowTrackCuts.cxx:4275
 AliFlowTrackCuts.cxx:4276
 AliFlowTrackCuts.cxx:4277
 AliFlowTrackCuts.cxx:4278
 AliFlowTrackCuts.cxx:4279
 AliFlowTrackCuts.cxx:4280
 AliFlowTrackCuts.cxx:4281
 AliFlowTrackCuts.cxx:4282
 AliFlowTrackCuts.cxx:4283
 AliFlowTrackCuts.cxx:4284
 AliFlowTrackCuts.cxx:4285
 AliFlowTrackCuts.cxx:4286
 AliFlowTrackCuts.cxx:4287
 AliFlowTrackCuts.cxx:4288
 AliFlowTrackCuts.cxx:4289
 AliFlowTrackCuts.cxx:4290
 AliFlowTrackCuts.cxx:4291
 AliFlowTrackCuts.cxx:4292
 AliFlowTrackCuts.cxx:4293
 AliFlowTrackCuts.cxx:4294
 AliFlowTrackCuts.cxx:4295
 AliFlowTrackCuts.cxx:4296
 AliFlowTrackCuts.cxx:4297
 AliFlowTrackCuts.cxx:4298
 AliFlowTrackCuts.cxx:4299
 AliFlowTrackCuts.cxx:4300
 AliFlowTrackCuts.cxx:4301
 AliFlowTrackCuts.cxx:4302
 AliFlowTrackCuts.cxx:4303
 AliFlowTrackCuts.cxx:4304
 AliFlowTrackCuts.cxx:4305
 AliFlowTrackCuts.cxx:4306
 AliFlowTrackCuts.cxx:4307
 AliFlowTrackCuts.cxx:4308
 AliFlowTrackCuts.cxx:4309
 AliFlowTrackCuts.cxx:4310
 AliFlowTrackCuts.cxx:4311
 AliFlowTrackCuts.cxx:4312
 AliFlowTrackCuts.cxx:4313
 AliFlowTrackCuts.cxx:4314
 AliFlowTrackCuts.cxx:4315
 AliFlowTrackCuts.cxx:4316
 AliFlowTrackCuts.cxx:4317
 AliFlowTrackCuts.cxx:4318
 AliFlowTrackCuts.cxx:4319
 AliFlowTrackCuts.cxx:4320
 AliFlowTrackCuts.cxx:4321
 AliFlowTrackCuts.cxx:4322
 AliFlowTrackCuts.cxx:4323
 AliFlowTrackCuts.cxx:4324
 AliFlowTrackCuts.cxx:4325
 AliFlowTrackCuts.cxx:4326
 AliFlowTrackCuts.cxx:4327
 AliFlowTrackCuts.cxx:4328
 AliFlowTrackCuts.cxx:4329
 AliFlowTrackCuts.cxx:4330
 AliFlowTrackCuts.cxx:4331
 AliFlowTrackCuts.cxx:4332
 AliFlowTrackCuts.cxx:4333
 AliFlowTrackCuts.cxx:4334
 AliFlowTrackCuts.cxx:4335
 AliFlowTrackCuts.cxx:4336
 AliFlowTrackCuts.cxx:4337
 AliFlowTrackCuts.cxx:4338
 AliFlowTrackCuts.cxx:4339
 AliFlowTrackCuts.cxx:4340
 AliFlowTrackCuts.cxx:4341
 AliFlowTrackCuts.cxx:4342
 AliFlowTrackCuts.cxx:4343
 AliFlowTrackCuts.cxx:4344
 AliFlowTrackCuts.cxx:4345
 AliFlowTrackCuts.cxx:4346
 AliFlowTrackCuts.cxx:4347
 AliFlowTrackCuts.cxx:4348
 AliFlowTrackCuts.cxx:4349
 AliFlowTrackCuts.cxx:4350
 AliFlowTrackCuts.cxx:4351
 AliFlowTrackCuts.cxx:4352
 AliFlowTrackCuts.cxx:4353
 AliFlowTrackCuts.cxx:4354
 AliFlowTrackCuts.cxx:4355
 AliFlowTrackCuts.cxx:4356
 AliFlowTrackCuts.cxx:4357
 AliFlowTrackCuts.cxx:4358
 AliFlowTrackCuts.cxx:4359
 AliFlowTrackCuts.cxx:4360
 AliFlowTrackCuts.cxx:4361
 AliFlowTrackCuts.cxx:4362
 AliFlowTrackCuts.cxx:4363
 AliFlowTrackCuts.cxx:4364
 AliFlowTrackCuts.cxx:4365
 AliFlowTrackCuts.cxx:4366
 AliFlowTrackCuts.cxx:4367
 AliFlowTrackCuts.cxx:4368
 AliFlowTrackCuts.cxx:4369
 AliFlowTrackCuts.cxx:4370
 AliFlowTrackCuts.cxx:4371
 AliFlowTrackCuts.cxx:4372
 AliFlowTrackCuts.cxx:4373
 AliFlowTrackCuts.cxx:4374
 AliFlowTrackCuts.cxx:4375
 AliFlowTrackCuts.cxx:4376
 AliFlowTrackCuts.cxx:4377
 AliFlowTrackCuts.cxx:4378
 AliFlowTrackCuts.cxx:4379
 AliFlowTrackCuts.cxx:4380
 AliFlowTrackCuts.cxx:4381
 AliFlowTrackCuts.cxx:4382
 AliFlowTrackCuts.cxx:4383
 AliFlowTrackCuts.cxx:4384
 AliFlowTrackCuts.cxx:4385
 AliFlowTrackCuts.cxx:4386
 AliFlowTrackCuts.cxx:4387
 AliFlowTrackCuts.cxx:4388
 AliFlowTrackCuts.cxx:4389
 AliFlowTrackCuts.cxx:4390
 AliFlowTrackCuts.cxx:4391
 AliFlowTrackCuts.cxx:4392
 AliFlowTrackCuts.cxx:4393
 AliFlowTrackCuts.cxx:4394
 AliFlowTrackCuts.cxx:4395
 AliFlowTrackCuts.cxx:4396
 AliFlowTrackCuts.cxx:4397
 AliFlowTrackCuts.cxx:4398
 AliFlowTrackCuts.cxx:4399
 AliFlowTrackCuts.cxx:4400
 AliFlowTrackCuts.cxx:4401
 AliFlowTrackCuts.cxx:4402
 AliFlowTrackCuts.cxx:4403
 AliFlowTrackCuts.cxx:4404
 AliFlowTrackCuts.cxx:4405
 AliFlowTrackCuts.cxx:4406
 AliFlowTrackCuts.cxx:4407
 AliFlowTrackCuts.cxx:4408
 AliFlowTrackCuts.cxx:4409
 AliFlowTrackCuts.cxx:4410
 AliFlowTrackCuts.cxx:4411
 AliFlowTrackCuts.cxx:4412
 AliFlowTrackCuts.cxx:4413
 AliFlowTrackCuts.cxx:4414
 AliFlowTrackCuts.cxx:4415
 AliFlowTrackCuts.cxx:4416
 AliFlowTrackCuts.cxx:4417
 AliFlowTrackCuts.cxx:4418
 AliFlowTrackCuts.cxx:4419
 AliFlowTrackCuts.cxx:4420
 AliFlowTrackCuts.cxx:4421
 AliFlowTrackCuts.cxx:4422
 AliFlowTrackCuts.cxx:4423
 AliFlowTrackCuts.cxx:4424
 AliFlowTrackCuts.cxx:4425
 AliFlowTrackCuts.cxx:4426
 AliFlowTrackCuts.cxx:4427
 AliFlowTrackCuts.cxx:4428
 AliFlowTrackCuts.cxx:4429
 AliFlowTrackCuts.cxx:4430
 AliFlowTrackCuts.cxx:4431
 AliFlowTrackCuts.cxx:4432
 AliFlowTrackCuts.cxx:4433
 AliFlowTrackCuts.cxx:4434
 AliFlowTrackCuts.cxx:4435
 AliFlowTrackCuts.cxx:4436
 AliFlowTrackCuts.cxx:4437
 AliFlowTrackCuts.cxx:4438
 AliFlowTrackCuts.cxx:4439
 AliFlowTrackCuts.cxx:4440
 AliFlowTrackCuts.cxx:4441
 AliFlowTrackCuts.cxx:4442
 AliFlowTrackCuts.cxx:4443
 AliFlowTrackCuts.cxx:4444
 AliFlowTrackCuts.cxx:4445
 AliFlowTrackCuts.cxx:4446
 AliFlowTrackCuts.cxx:4447
 AliFlowTrackCuts.cxx:4448
 AliFlowTrackCuts.cxx:4449
 AliFlowTrackCuts.cxx:4450
 AliFlowTrackCuts.cxx:4451
 AliFlowTrackCuts.cxx:4452
 AliFlowTrackCuts.cxx:4453
 AliFlowTrackCuts.cxx:4454
 AliFlowTrackCuts.cxx:4455
 AliFlowTrackCuts.cxx:4456
 AliFlowTrackCuts.cxx:4457
 AliFlowTrackCuts.cxx:4458
 AliFlowTrackCuts.cxx:4459
 AliFlowTrackCuts.cxx:4460
 AliFlowTrackCuts.cxx:4461
 AliFlowTrackCuts.cxx:4462
 AliFlowTrackCuts.cxx:4463
 AliFlowTrackCuts.cxx:4464
 AliFlowTrackCuts.cxx:4465
 AliFlowTrackCuts.cxx:4466
 AliFlowTrackCuts.cxx:4467
 AliFlowTrackCuts.cxx:4468
 AliFlowTrackCuts.cxx:4469
 AliFlowTrackCuts.cxx:4470
 AliFlowTrackCuts.cxx:4471
 AliFlowTrackCuts.cxx:4472
 AliFlowTrackCuts.cxx:4473
 AliFlowTrackCuts.cxx:4474
 AliFlowTrackCuts.cxx:4475
 AliFlowTrackCuts.cxx:4476
 AliFlowTrackCuts.cxx:4477
 AliFlowTrackCuts.cxx:4478
 AliFlowTrackCuts.cxx:4479
 AliFlowTrackCuts.cxx:4480
 AliFlowTrackCuts.cxx:4481
 AliFlowTrackCuts.cxx:4482
 AliFlowTrackCuts.cxx:4483
 AliFlowTrackCuts.cxx:4484
 AliFlowTrackCuts.cxx:4485
 AliFlowTrackCuts.cxx:4486
 AliFlowTrackCuts.cxx:4487
 AliFlowTrackCuts.cxx:4488
 AliFlowTrackCuts.cxx:4489
 AliFlowTrackCuts.cxx:4490
 AliFlowTrackCuts.cxx:4491
 AliFlowTrackCuts.cxx:4492
 AliFlowTrackCuts.cxx:4493
 AliFlowTrackCuts.cxx:4494
 AliFlowTrackCuts.cxx:4495
 AliFlowTrackCuts.cxx:4496
 AliFlowTrackCuts.cxx:4497
 AliFlowTrackCuts.cxx:4498
 AliFlowTrackCuts.cxx:4499
 AliFlowTrackCuts.cxx:4500
 AliFlowTrackCuts.cxx:4501
 AliFlowTrackCuts.cxx:4502
 AliFlowTrackCuts.cxx:4503
 AliFlowTrackCuts.cxx:4504
 AliFlowTrackCuts.cxx:4505
 AliFlowTrackCuts.cxx:4506
 AliFlowTrackCuts.cxx:4507
 AliFlowTrackCuts.cxx:4508
 AliFlowTrackCuts.cxx:4509
 AliFlowTrackCuts.cxx:4510
 AliFlowTrackCuts.cxx:4511
 AliFlowTrackCuts.cxx:4512
 AliFlowTrackCuts.cxx:4513
 AliFlowTrackCuts.cxx:4514
 AliFlowTrackCuts.cxx:4515
 AliFlowTrackCuts.cxx:4516
 AliFlowTrackCuts.cxx:4517
 AliFlowTrackCuts.cxx:4518
 AliFlowTrackCuts.cxx:4519
 AliFlowTrackCuts.cxx:4520
 AliFlowTrackCuts.cxx:4521
 AliFlowTrackCuts.cxx:4522
 AliFlowTrackCuts.cxx:4523
 AliFlowTrackCuts.cxx:4524
 AliFlowTrackCuts.cxx:4525
 AliFlowTrackCuts.cxx:4526
 AliFlowTrackCuts.cxx:4527
 AliFlowTrackCuts.cxx:4528
 AliFlowTrackCuts.cxx:4529
 AliFlowTrackCuts.cxx:4530
 AliFlowTrackCuts.cxx:4531
 AliFlowTrackCuts.cxx:4532
 AliFlowTrackCuts.cxx:4533
 AliFlowTrackCuts.cxx:4534
 AliFlowTrackCuts.cxx:4535
 AliFlowTrackCuts.cxx:4536
 AliFlowTrackCuts.cxx:4537
 AliFlowTrackCuts.cxx:4538
 AliFlowTrackCuts.cxx:4539
 AliFlowTrackCuts.cxx:4540
 AliFlowTrackCuts.cxx:4541
 AliFlowTrackCuts.cxx:4542
 AliFlowTrackCuts.cxx:4543
 AliFlowTrackCuts.cxx:4544
 AliFlowTrackCuts.cxx:4545
 AliFlowTrackCuts.cxx:4546
 AliFlowTrackCuts.cxx:4547
 AliFlowTrackCuts.cxx:4548
 AliFlowTrackCuts.cxx:4549
 AliFlowTrackCuts.cxx:4550
 AliFlowTrackCuts.cxx:4551
 AliFlowTrackCuts.cxx:4552
 AliFlowTrackCuts.cxx:4553
 AliFlowTrackCuts.cxx:4554
 AliFlowTrackCuts.cxx:4555
 AliFlowTrackCuts.cxx:4556
 AliFlowTrackCuts.cxx:4557
 AliFlowTrackCuts.cxx:4558
 AliFlowTrackCuts.cxx:4559
 AliFlowTrackCuts.cxx:4560
 AliFlowTrackCuts.cxx:4561
 AliFlowTrackCuts.cxx:4562
 AliFlowTrackCuts.cxx:4563
 AliFlowTrackCuts.cxx:4564
 AliFlowTrackCuts.cxx:4565
 AliFlowTrackCuts.cxx:4566
 AliFlowTrackCuts.cxx:4567
 AliFlowTrackCuts.cxx:4568
 AliFlowTrackCuts.cxx:4569
 AliFlowTrackCuts.cxx:4570
 AliFlowTrackCuts.cxx:4571
 AliFlowTrackCuts.cxx:4572
 AliFlowTrackCuts.cxx:4573
 AliFlowTrackCuts.cxx:4574
 AliFlowTrackCuts.cxx:4575
 AliFlowTrackCuts.cxx:4576
 AliFlowTrackCuts.cxx:4577
 AliFlowTrackCuts.cxx:4578
 AliFlowTrackCuts.cxx:4579
 AliFlowTrackCuts.cxx:4580
 AliFlowTrackCuts.cxx:4581
 AliFlowTrackCuts.cxx:4582
 AliFlowTrackCuts.cxx:4583
 AliFlowTrackCuts.cxx:4584
 AliFlowTrackCuts.cxx:4585
 AliFlowTrackCuts.cxx:4586
 AliFlowTrackCuts.cxx:4587
 AliFlowTrackCuts.cxx:4588
 AliFlowTrackCuts.cxx:4589
 AliFlowTrackCuts.cxx:4590
 AliFlowTrackCuts.cxx:4591
 AliFlowTrackCuts.cxx:4592
 AliFlowTrackCuts.cxx:4593
 AliFlowTrackCuts.cxx:4594
 AliFlowTrackCuts.cxx:4595
 AliFlowTrackCuts.cxx:4596
 AliFlowTrackCuts.cxx:4597
 AliFlowTrackCuts.cxx:4598
 AliFlowTrackCuts.cxx:4599
 AliFlowTrackCuts.cxx:4600
 AliFlowTrackCuts.cxx:4601
 AliFlowTrackCuts.cxx:4602
 AliFlowTrackCuts.cxx:4603
 AliFlowTrackCuts.cxx:4604
 AliFlowTrackCuts.cxx:4605
 AliFlowTrackCuts.cxx:4606
 AliFlowTrackCuts.cxx:4607
 AliFlowTrackCuts.cxx:4608
 AliFlowTrackCuts.cxx:4609
 AliFlowTrackCuts.cxx:4610
 AliFlowTrackCuts.cxx:4611
 AliFlowTrackCuts.cxx:4612
 AliFlowTrackCuts.cxx:4613
 AliFlowTrackCuts.cxx:4614
 AliFlowTrackCuts.cxx:4615
 AliFlowTrackCuts.cxx:4616
 AliFlowTrackCuts.cxx:4617
 AliFlowTrackCuts.cxx:4618
 AliFlowTrackCuts.cxx:4619
 AliFlowTrackCuts.cxx:4620
 AliFlowTrackCuts.cxx:4621
 AliFlowTrackCuts.cxx:4622
 AliFlowTrackCuts.cxx:4623
 AliFlowTrackCuts.cxx:4624
 AliFlowTrackCuts.cxx:4625
 AliFlowTrackCuts.cxx:4626
 AliFlowTrackCuts.cxx:4627
 AliFlowTrackCuts.cxx:4628
 AliFlowTrackCuts.cxx:4629
 AliFlowTrackCuts.cxx:4630
 AliFlowTrackCuts.cxx:4631
 AliFlowTrackCuts.cxx:4632
 AliFlowTrackCuts.cxx:4633
 AliFlowTrackCuts.cxx:4634
 AliFlowTrackCuts.cxx:4635
 AliFlowTrackCuts.cxx:4636
 AliFlowTrackCuts.cxx:4637
 AliFlowTrackCuts.cxx:4638
 AliFlowTrackCuts.cxx:4639
 AliFlowTrackCuts.cxx:4640
 AliFlowTrackCuts.cxx:4641
 AliFlowTrackCuts.cxx:4642
 AliFlowTrackCuts.cxx:4643
 AliFlowTrackCuts.cxx:4644
 AliFlowTrackCuts.cxx:4645
 AliFlowTrackCuts.cxx:4646
 AliFlowTrackCuts.cxx:4647
 AliFlowTrackCuts.cxx:4648
 AliFlowTrackCuts.cxx:4649
 AliFlowTrackCuts.cxx:4650
 AliFlowTrackCuts.cxx:4651
 AliFlowTrackCuts.cxx:4652
 AliFlowTrackCuts.cxx:4653
 AliFlowTrackCuts.cxx:4654
 AliFlowTrackCuts.cxx:4655
 AliFlowTrackCuts.cxx:4656
 AliFlowTrackCuts.cxx:4657
 AliFlowTrackCuts.cxx:4658
 AliFlowTrackCuts.cxx:4659
 AliFlowTrackCuts.cxx:4660
 AliFlowTrackCuts.cxx:4661
 AliFlowTrackCuts.cxx:4662
 AliFlowTrackCuts.cxx:4663
 AliFlowTrackCuts.cxx:4664
 AliFlowTrackCuts.cxx:4665
 AliFlowTrackCuts.cxx:4666
 AliFlowTrackCuts.cxx:4667
 AliFlowTrackCuts.cxx:4668
 AliFlowTrackCuts.cxx:4669
 AliFlowTrackCuts.cxx:4670
 AliFlowTrackCuts.cxx:4671
 AliFlowTrackCuts.cxx:4672
 AliFlowTrackCuts.cxx:4673
 AliFlowTrackCuts.cxx:4674
 AliFlowTrackCuts.cxx:4675
 AliFlowTrackCuts.cxx:4676
 AliFlowTrackCuts.cxx:4677
 AliFlowTrackCuts.cxx:4678
 AliFlowTrackCuts.cxx:4679
 AliFlowTrackCuts.cxx:4680
 AliFlowTrackCuts.cxx:4681
 AliFlowTrackCuts.cxx:4682
 AliFlowTrackCuts.cxx:4683
 AliFlowTrackCuts.cxx:4684
 AliFlowTrackCuts.cxx:4685
 AliFlowTrackCuts.cxx:4686
 AliFlowTrackCuts.cxx:4687
 AliFlowTrackCuts.cxx:4688
 AliFlowTrackCuts.cxx:4689
 AliFlowTrackCuts.cxx:4690
 AliFlowTrackCuts.cxx:4691
 AliFlowTrackCuts.cxx:4692
 AliFlowTrackCuts.cxx:4693
 AliFlowTrackCuts.cxx:4694
 AliFlowTrackCuts.cxx:4695
 AliFlowTrackCuts.cxx:4696
 AliFlowTrackCuts.cxx:4697
 AliFlowTrackCuts.cxx:4698
 AliFlowTrackCuts.cxx:4699
 AliFlowTrackCuts.cxx:4700
 AliFlowTrackCuts.cxx:4701
 AliFlowTrackCuts.cxx:4702
 AliFlowTrackCuts.cxx:4703
 AliFlowTrackCuts.cxx:4704
 AliFlowTrackCuts.cxx:4705
 AliFlowTrackCuts.cxx:4706
 AliFlowTrackCuts.cxx:4707
 AliFlowTrackCuts.cxx:4708
 AliFlowTrackCuts.cxx:4709
 AliFlowTrackCuts.cxx:4710
 AliFlowTrackCuts.cxx:4711
 AliFlowTrackCuts.cxx:4712
 AliFlowTrackCuts.cxx:4713
 AliFlowTrackCuts.cxx:4714
 AliFlowTrackCuts.cxx:4715
 AliFlowTrackCuts.cxx:4716
 AliFlowTrackCuts.cxx:4717
 AliFlowTrackCuts.cxx:4718
 AliFlowTrackCuts.cxx:4719
 AliFlowTrackCuts.cxx:4720
 AliFlowTrackCuts.cxx:4721
 AliFlowTrackCuts.cxx:4722
 AliFlowTrackCuts.cxx:4723
 AliFlowTrackCuts.cxx:4724
 AliFlowTrackCuts.cxx:4725
 AliFlowTrackCuts.cxx:4726
 AliFlowTrackCuts.cxx:4727
 AliFlowTrackCuts.cxx:4728
 AliFlowTrackCuts.cxx:4729
 AliFlowTrackCuts.cxx:4730
 AliFlowTrackCuts.cxx:4731
 AliFlowTrackCuts.cxx:4732
 AliFlowTrackCuts.cxx:4733
 AliFlowTrackCuts.cxx:4734
 AliFlowTrackCuts.cxx:4735
 AliFlowTrackCuts.cxx:4736
 AliFlowTrackCuts.cxx:4737
 AliFlowTrackCuts.cxx:4738
 AliFlowTrackCuts.cxx:4739
 AliFlowTrackCuts.cxx:4740
 AliFlowTrackCuts.cxx:4741
 AliFlowTrackCuts.cxx:4742
 AliFlowTrackCuts.cxx:4743
 AliFlowTrackCuts.cxx:4744
 AliFlowTrackCuts.cxx:4745
 AliFlowTrackCuts.cxx:4746
 AliFlowTrackCuts.cxx:4747
 AliFlowTrackCuts.cxx:4748
 AliFlowTrackCuts.cxx:4749
 AliFlowTrackCuts.cxx:4750
 AliFlowTrackCuts.cxx:4751
 AliFlowTrackCuts.cxx:4752
 AliFlowTrackCuts.cxx:4753
 AliFlowTrackCuts.cxx:4754
 AliFlowTrackCuts.cxx:4755
 AliFlowTrackCuts.cxx:4756
 AliFlowTrackCuts.cxx:4757
 AliFlowTrackCuts.cxx:4758
 AliFlowTrackCuts.cxx:4759
 AliFlowTrackCuts.cxx:4760
 AliFlowTrackCuts.cxx:4761
 AliFlowTrackCuts.cxx:4762
 AliFlowTrackCuts.cxx:4763
 AliFlowTrackCuts.cxx:4764
 AliFlowTrackCuts.cxx:4765
 AliFlowTrackCuts.cxx:4766
 AliFlowTrackCuts.cxx:4767
 AliFlowTrackCuts.cxx:4768
 AliFlowTrackCuts.cxx:4769
 AliFlowTrackCuts.cxx:4770
 AliFlowTrackCuts.cxx:4771
 AliFlowTrackCuts.cxx:4772
 AliFlowTrackCuts.cxx:4773
 AliFlowTrackCuts.cxx:4774
 AliFlowTrackCuts.cxx:4775
 AliFlowTrackCuts.cxx:4776
 AliFlowTrackCuts.cxx:4777
 AliFlowTrackCuts.cxx:4778
 AliFlowTrackCuts.cxx:4779
 AliFlowTrackCuts.cxx:4780
 AliFlowTrackCuts.cxx:4781
 AliFlowTrackCuts.cxx:4782
 AliFlowTrackCuts.cxx:4783
 AliFlowTrackCuts.cxx:4784
 AliFlowTrackCuts.cxx:4785
 AliFlowTrackCuts.cxx:4786
 AliFlowTrackCuts.cxx:4787
 AliFlowTrackCuts.cxx:4788
 AliFlowTrackCuts.cxx:4789
 AliFlowTrackCuts.cxx:4790
 AliFlowTrackCuts.cxx:4791
 AliFlowTrackCuts.cxx:4792
 AliFlowTrackCuts.cxx:4793
 AliFlowTrackCuts.cxx:4794
 AliFlowTrackCuts.cxx:4795
 AliFlowTrackCuts.cxx:4796
 AliFlowTrackCuts.cxx:4797
 AliFlowTrackCuts.cxx:4798
 AliFlowTrackCuts.cxx:4799
 AliFlowTrackCuts.cxx:4800
 AliFlowTrackCuts.cxx:4801
 AliFlowTrackCuts.cxx:4802
 AliFlowTrackCuts.cxx:4803
 AliFlowTrackCuts.cxx:4804
 AliFlowTrackCuts.cxx:4805
 AliFlowTrackCuts.cxx:4806
 AliFlowTrackCuts.cxx:4807
 AliFlowTrackCuts.cxx:4808
 AliFlowTrackCuts.cxx:4809
 AliFlowTrackCuts.cxx:4810
 AliFlowTrackCuts.cxx:4811
 AliFlowTrackCuts.cxx:4812
 AliFlowTrackCuts.cxx:4813
 AliFlowTrackCuts.cxx:4814
 AliFlowTrackCuts.cxx:4815
 AliFlowTrackCuts.cxx:4816
 AliFlowTrackCuts.cxx:4817
 AliFlowTrackCuts.cxx:4818
 AliFlowTrackCuts.cxx:4819
 AliFlowTrackCuts.cxx:4820
 AliFlowTrackCuts.cxx:4821
 AliFlowTrackCuts.cxx:4822
 AliFlowTrackCuts.cxx:4823
 AliFlowTrackCuts.cxx:4824
 AliFlowTrackCuts.cxx:4825
 AliFlowTrackCuts.cxx:4826
 AliFlowTrackCuts.cxx:4827
 AliFlowTrackCuts.cxx:4828
 AliFlowTrackCuts.cxx:4829
 AliFlowTrackCuts.cxx:4830
 AliFlowTrackCuts.cxx:4831
 AliFlowTrackCuts.cxx:4832
 AliFlowTrackCuts.cxx:4833
 AliFlowTrackCuts.cxx:4834
 AliFlowTrackCuts.cxx:4835
 AliFlowTrackCuts.cxx:4836
 AliFlowTrackCuts.cxx:4837
 AliFlowTrackCuts.cxx:4838
 AliFlowTrackCuts.cxx:4839
 AliFlowTrackCuts.cxx:4840
 AliFlowTrackCuts.cxx:4841
 AliFlowTrackCuts.cxx:4842
 AliFlowTrackCuts.cxx:4843
 AliFlowTrackCuts.cxx:4844
 AliFlowTrackCuts.cxx:4845
 AliFlowTrackCuts.cxx:4846
 AliFlowTrackCuts.cxx:4847
 AliFlowTrackCuts.cxx:4848
 AliFlowTrackCuts.cxx:4849
 AliFlowTrackCuts.cxx:4850
 AliFlowTrackCuts.cxx:4851
 AliFlowTrackCuts.cxx:4852
 AliFlowTrackCuts.cxx:4853
 AliFlowTrackCuts.cxx:4854
 AliFlowTrackCuts.cxx:4855
 AliFlowTrackCuts.cxx:4856
 AliFlowTrackCuts.cxx:4857
 AliFlowTrackCuts.cxx:4858
 AliFlowTrackCuts.cxx:4859
 AliFlowTrackCuts.cxx:4860
 AliFlowTrackCuts.cxx:4861
 AliFlowTrackCuts.cxx:4862
 AliFlowTrackCuts.cxx:4863
 AliFlowTrackCuts.cxx:4864
 AliFlowTrackCuts.cxx:4865
 AliFlowTrackCuts.cxx:4866
 AliFlowTrackCuts.cxx:4867
 AliFlowTrackCuts.cxx:4868
 AliFlowTrackCuts.cxx:4869
 AliFlowTrackCuts.cxx:4870
 AliFlowTrackCuts.cxx:4871
 AliFlowTrackCuts.cxx:4872
 AliFlowTrackCuts.cxx:4873
 AliFlowTrackCuts.cxx:4874
 AliFlowTrackCuts.cxx:4875
 AliFlowTrackCuts.cxx:4876
 AliFlowTrackCuts.cxx:4877
 AliFlowTrackCuts.cxx:4878
 AliFlowTrackCuts.cxx:4879
 AliFlowTrackCuts.cxx:4880
 AliFlowTrackCuts.cxx:4881
 AliFlowTrackCuts.cxx:4882
 AliFlowTrackCuts.cxx:4883
 AliFlowTrackCuts.cxx:4884
 AliFlowTrackCuts.cxx:4885
 AliFlowTrackCuts.cxx:4886
 AliFlowTrackCuts.cxx:4887
 AliFlowTrackCuts.cxx:4888
 AliFlowTrackCuts.cxx:4889
 AliFlowTrackCuts.cxx:4890
 AliFlowTrackCuts.cxx:4891
 AliFlowTrackCuts.cxx:4892
 AliFlowTrackCuts.cxx:4893
 AliFlowTrackCuts.cxx:4894
 AliFlowTrackCuts.cxx:4895
 AliFlowTrackCuts.cxx:4896
 AliFlowTrackCuts.cxx:4897
 AliFlowTrackCuts.cxx:4898
 AliFlowTrackCuts.cxx:4899
 AliFlowTrackCuts.cxx:4900
 AliFlowTrackCuts.cxx:4901
 AliFlowTrackCuts.cxx:4902
 AliFlowTrackCuts.cxx:4903
 AliFlowTrackCuts.cxx:4904
 AliFlowTrackCuts.cxx:4905
 AliFlowTrackCuts.cxx:4906
 AliFlowTrackCuts.cxx:4907
 AliFlowTrackCuts.cxx:4908
 AliFlowTrackCuts.cxx:4909
 AliFlowTrackCuts.cxx:4910
 AliFlowTrackCuts.cxx:4911
 AliFlowTrackCuts.cxx:4912
 AliFlowTrackCuts.cxx:4913
 AliFlowTrackCuts.cxx:4914
 AliFlowTrackCuts.cxx:4915
 AliFlowTrackCuts.cxx:4916
 AliFlowTrackCuts.cxx:4917
 AliFlowTrackCuts.cxx:4918
 AliFlowTrackCuts.cxx:4919
 AliFlowTrackCuts.cxx:4920
 AliFlowTrackCuts.cxx:4921
 AliFlowTrackCuts.cxx:4922
 AliFlowTrackCuts.cxx:4923
 AliFlowTrackCuts.cxx:4924
 AliFlowTrackCuts.cxx:4925
 AliFlowTrackCuts.cxx:4926
 AliFlowTrackCuts.cxx:4927
 AliFlowTrackCuts.cxx:4928