Fixed some coding violations
authorsnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 26 Feb 2007 11:37:22 +0000 (11:37 +0000)
committersnelling <snelling@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 26 Feb 2007 11:37:22 +0000 (11:37 +0000)
19 files changed:
PWG2/FLOW/AliFlowAnalyser.cxx
PWG2/FLOW/AliFlowAnalyser.h
PWG2/FLOW/AliFlowConstants.cxx
PWG2/FLOW/AliFlowConstants.h
PWG2/FLOW/AliFlowEvent.cxx
PWG2/FLOW/AliFlowEvent.h
PWG2/FLOW/AliFlowMaker.cxx
PWG2/FLOW/AliFlowMaker.h
PWG2/FLOW/AliFlowSelection.cxx
PWG2/FLOW/AliFlowSelection.h
PWG2/FLOW/AliFlowTrack.cxx
PWG2/FLOW/AliFlowTrack.h
PWG2/FLOW/AliFlowWeighter.cxx
PWG2/FLOW/AliFlowWeighter.h
PWG2/FLOW/AliSelectorFoF.cxx
PWG2/FLOW/AliSelectorFoF.h
PWG2/FLOW/macros/testAnal.C
PWG2/FLOW/macros/testMaker.C
PWG2/FLOW/macros/testWeight.C

index 3c28cff7026f1b57e556dd237c7b42b8fe85251b..57331bb55aac32fc6e25c019c9149dd2b4098937 100644 (file)
@@ -97,7 +97,7 @@ AliFlowAnalyser::AliFlowAnalyser(const AliFlowSelection* flowSelect)
 
  // for phi weights
  fPhiWgtFile   = 0 ;
- fPhiBins = Flow::nPhiBins ;     
+ fPhiBins = AliFlowConstants::kPhiBins ;     
  fPhiMin  = 0.;
  fPhiMax  = 2*TMath::Pi() ; 
 
@@ -158,116 +158,116 @@ Bool_t AliFlowAnalyser::Init()
  }
  
  // Histogram settings
- fLabel = "Pseudorapidity" ;           if(strlen(fFlowSelect->PidPart()) != 0)            { fLabel = "Rapidity"; }
- fPtMaxPart = Flow::fPtMaxPart ;       if(fFlowSelect->PtMaxPart())    { fPtMaxPart = fFlowSelect->PtMaxPart() ; }
- fPtBinsPart = Flow::nPtBinsPart ;     if(fFlowSelect->PtBinsPart()) { fPtBinsPart = fFlowSelect->PtBinsPart() ; }
- fPtMin = Flow::fPtMin ;       
- fPtMax = Flow::fPtMax ;       
- fEtaMin = Flow::fEtaMin ;
- fEtaMax = Flow::fEtaMax ;
- fPtBins  = Flow::nPtBins ;      
- fEtaBins = Flow::nEtaBins ;      
+ fLabel = "Pseudorapidity" ;                   if(strlen(fFlowSelect->PidPart()) != 0)            { fLabel = "Rapidity"; }
+ fPtMaxPart = AliFlowConstants::fgPtMaxPart ;          if(fFlowSelect->PtMaxPart())    { fPtMaxPart = fFlowSelect->PtMaxPart() ; }
+ fPtBinsPart = AliFlowConstants::kPtBinsPart ;  if(fFlowSelect->PtBinsPart()) { fPtBinsPart = fFlowSelect->PtBinsPart() ; }
+ fPtMin = AliFlowConstants::fgPtMin ;       
+ fPtMax = AliFlowConstants::fgPtMax ;       
+ fEtaMin = AliFlowConstants::fgEtaMin ;
+ fEtaMax = AliFlowConstants::fgEtaMax ;
+ fPtBins  = AliFlowConstants::kPtBins ;      
+ fEtaBins = AliFlowConstants::kEtaBins ;      
  // -
- SetPtRangevEta(1.,0.);   // (Flow::fPtMin , Flow::fPtMax) ;
- SetEtaRangevPt(1.,0.);   // (Flow::fEtaMin , Flow::fEtaMax) ;
+ SetPtRangevEta(1.,0.);   // (AliFlowConstants::fgPtMin , AliFlowConstants::fgPtMax) ;
+ SetEtaRangevPt(1.,0.);   // (AliFlowConstants::fgEtaMin , AliFlowConstants::fgEtaMax) ;
  // -
const float triggerMin      =  -1.5;
const float triggerMax      =  10.5;
const float chargeMin       =  -2.5;
const float chargeMax       =   2.5; 
const float dcaMin         =   0.0;
const float dcaMax         =  10.0; //  0.5; 
const float glDcaMax       =  50.0; 
const float chi2Min        =    0.;
const float chi2Max        =  500.; 
const float chi2normMax     =   50.; 
const float chi2MaxC       =   30.; 
const float chi2MaxI       =   60.; 
const float fitPtsMin       =  -0.5;
const float fitPtsMaxTpc    = 160.5;
const float fitPtsMaxIts    =   6.5;
const float fitPtsMaxTrd    = 130.5;
const float fitPtsMaxTof    =   1.5;
const float fitOverMaxMin   =    0.;
const float fitOverMaxMax   =   1.1;
const float multOverOrigMin =    0.;
const float multOverOrigMax =    1.;
const float vertexZMin      =  -10.;
const float vertexZMax      =   10.; 
const float vertexXYMin     =  -0.1;
const float vertexXYMax     =   0.1; 
const float etaSymMinPart   =   -1.;
const float etaSymMaxPart   =    1.;
const float etaSymMin       =   -2.;
const float etaSymMax       =    2.;
const float psiMin         =    0.;
const float psiMax         = 2*TMath::Pi() ; 
const float multMin        =    0. ;
const float multMax        =25000. ;
const float multV0         = 5000. ;
const float qMin           =    0. ;
const float qMax           =   20. ;
const float pidMin         =    0. ;
const float pidMax         =    1. ;
const float centMin        =  -0.5 ;
const float centMax        =   9.5 ;
const float logpMin        =  -2.5 ;
const float logpMax        =   2.5 ;
const float pMin           =    0. ;
const float pMax           =  100. ;
const float dEdxMax        = 1000. ;
const float dEdxMaxTPC             = 1500. ;
const float TOFmin         = 10000. ;
const float TOFmax         = 50000. ;
const float TRDmax         = 2000. ;
const float lgMin          = -1000. ;
const float lgMax          = 1000. ;
const float lgMinV0        =    0. ;
const float lgMaxV0        =   50. ;
const float massMin        =  -0.1 ;
const float massMax        =   2.1 ;
const float ZDCpartMin      =  -0.5 ;
const float ZDCpartMax             = 1000.5 ;
const float ZDCeMin        =    0. ;
const float ZDCeMax         = 10000. ;
+ float triggerMin      =  -1.5;
+ float triggerMax      =  10.5;
+ float chargeMin       =  -2.5;
+ float chargeMax       =   2.5; 
+ float dcaMin         =   0.0;
+ float dcaMax         =  10.0; //  0.5; 
float glDcaMax        =  50.0; 
float chi2Min         =    0.;
float chi2Max         =  500.; 
+ float chi2normMax     =   50.; 
float chi2MaxC        =   30.; 
float chi2MaxI        =   60.; 
+ float fitPtsMin       =  -0.5;
+ float fitPtsMaxTpc    = 160.5;
+ float fitPtsMaxIts    =   6.5;
+ float fitPtsMaxTrd    = 130.5;
+ float fitPtsMaxTof    =   1.5;
+ float fitOverMaxMin   =    0.;
+ float fitOverMaxMax   =   1.1;
+ float multOverOrigMin =    0.;
+ float multOverOrigMax =    1.;
+ float vertexZMin      =  -10.;
+ float vertexZMax      =   10.; 
+ float vertexXYMin     =  -0.1;
+ float vertexXYMax     =   0.1; 
+ float etaSymMinPart   =   -1.;
+ float etaSymMaxPart   =    1.;
+ float etaSymMin       =   -2.;
+ float etaSymMax       =    2.;
+ float psiMin         =    0.;
+ float psiMax         = 2*TMath::Pi() ; 
float multMin         =    0. ;
float multMax         =25000. ;
+ float multV0         = 5000. ;
+ float qMin           =    0. ;
+ float qMax           =   20. ;
+ float pidMin         =    0. ;
+ float pidMax         =    1. ;
float centMin         =  -0.5 ;
float centMax         =   9.5 ;
float logpMin         =  -2.5 ;
float logpMax         =   2.5 ;
+ float pMin           =    0. ;
+ float pMax           =  100. ;
float dEdxMax         = 1000. ;
float dEdxMaxTPC      = 1500. ;
float tofmin         = 10000. ;
float tofmax         = 50000. ;
float trdmax         = 2000. ;
+ float lgMin          = -1000. ;
+ float lgMax          = 1000. ;
float lgMinV0         =    0. ;
float lgMaxV0         =   50. ;
float massMin         =  -0.1 ;
float massMax         =   2.1 ;
float zdcpartMin      =  -0.5 ;
float zdcpartMax      = 1000.5 ;
float zdceMin         =    0. ;
float zdceMax         = 10000. ;
  // - 
- enum { nTriggerBins     = 12,
-       nChargeBins       = 5,
-       nDcaBins          = 1000,
-       nChi2Bins         = 150,
-       nFitPtsBinsTpc    = 161,
-       nFitPtsBinsIts    = 7,
-       nFitPtsBinsTrd    = 131,
-       nFitPtsBinsTof    = 2,
-       nFitOverMaxBins   = 55,
-       nMultOverOrigBins =100,
-       nVertexZBins      = 200,
-       nVertexXYBins     = 1000,
-       nEtaSymBins       = 200,
-       nPhi3DBins        = 60,
-       nPsiBins          = 36,
-       nMultBins         = 250,
-       nPidBins          = 100,
-        nCentBins        = 10,
-       nDedxBins         = 1000,
-       nTofBins          = 1000,
-       nTrdBins          = 100,
-       nMomenBins        = 500,
-       nQbins            =  50,
-       nLgBins           = 500,
-       nMassBins         = 2200,
-       nZDCpartBins      = 1001,
-       nZDCeBins         = 200
+ enum { kTriggerBins     = 12,
+       kChargeBins       = 5,
+       kDcaBins          = 1000,
+       kChi2Bins         = 150,
+       kFitPtsBinsTpc    = 161,
+       kFitPtsBinsIts    = 7,
+       kFitPtsBinsTrd    = 131,
+       kFitPtsBinsTof    = 2,
+       kFitOverMaxBins   = 55,
+       kMultOverOrigBins =100,
+       kVertexZBins      = 200,
+       kVertexXYBins     = 1000,
+       kEtaSymBins       = 200,
+       kPhi3DBins        = 60,
+       kPsiBins          = 36,
+       kMultBins         = 250,
+       kPidBins          = 100,
+        kCentBins        = 10,
+       kDedxBins         = 1000,
+       kTofBins          = 1000,
+       kTrdBins          = 100,
+       kMomenBins        = 500,
+       kQbins            =  50,
+       kLgBins           = 500,
+       kMassBins         = 2200,
+       kZDCpartBins      = 1001,
+       kZDCeBins         = 200
       } ;
 
  // Histograms Booking ...
  // Trigger
- fHistTrigger = new TH1F("Flow_Trigger", "Flow_Trigger", nTriggerBins, triggerMin, triggerMax);
+ fHistTrigger = new TH1F("Flow_Trigger", "Flow_Trigger", kTriggerBins, triggerMin, triggerMax);
  fHistTrigger->SetXTitle("Trigger: 1 minbias, 2 central, 3 laser, 10 other");
  fHistTrigger->SetYTitle("Counts");
 
  // Charge
- fHistCharge = new TH1F("Flow_Charge", "Flow_Charge", nChargeBins, chargeMin, chargeMax);
+ fHistCharge = new TH1F("Flow_Charge", "Flow_Charge", kChargeBins, chargeMin, chargeMax);
  fHistCharge->SetXTitle("Charge");
  fHistCharge->SetYTitle("Counts");
 
@@ -278,7 +278,7 @@ Bool_t AliFlowAnalyser::Init()
  fHistPtot->SetYTitle("Counts");
 
  // Reconstructed pT (constrained, if so)
- fHistPt = new TH1F("Flow_Pt","Flow_Pt", nMomenBins, pMin, pMax);
+ fHistPt = new TH1F("Flow_Pt","Flow_Pt", kMomenBins, pMin, pMax);
  fHistPt->Sumw2();
  fHistPt->SetXTitle("Pt (GeV/c)");
  fHistPt->SetYTitle("Counts");
@@ -290,31 +290,31 @@ Bool_t AliFlowAnalyser::Init()
  fHistPidPt->SetYTitle("Pt (GeV/c)");
    
  // Distance of closest approach - Transverse, Unsigned
- fHistDca = new TH1F("Flow_TransDCA", "Flow_TransverseDCA", nDcaBins, dcaMin, dcaMax);
+ fHistDca = new TH1F("Flow_TransDCA", "Flow_TransverseDCA", kDcaBins, dcaMin, dcaMax);
  fHistDca->Sumw2();
  fHistDca->SetXTitle("|Track's Signed dca (cm)|");
  fHistDca->SetYTitle("Counts");
 
  // Distance of closest approach - Transverse
- fHistTransDca = new TH1F("Flow_TransDCA_Signed", "Flow_TransverseDCA_Signed", nDcaBins, -dcaMax, dcaMax);
+ fHistTransDca = new TH1F("Flow_TransDCA_Signed", "Flow_TransverseDCA_Signed", kDcaBins, -dcaMax, dcaMax);
  fHistTransDca->Sumw2();
  fHistTransDca->SetXTitle("Track's Transverse dca (cm)");
  fHistTransDca->SetYTitle("Counts");
 
  // Distance of closest approach - 3d
- fHistDcaGlobal = new TH1F("Flow_3dDcaGlobal", "Flow_3dDcaGlobal", nDcaBins, dcaMin, glDcaMax);
+ fHistDcaGlobal = new TH1F("Flow_3dDcaGlobal", "Flow_3dDcaGlobal", kDcaBins, dcaMin, glDcaMax);
  fHistDcaGlobal->Sumw2();
  fHistDcaGlobal->SetXTitle("|3d Global Track's dca to Vertex (cm)|");
  fHistDcaGlobal->SetYTitle("Counts");
 
  // Distance of closest approach for particles correlated with the event plane - 3d
- fHistDcaGlobalPart = new TH1F("Flow_3dDcaGlobalPart", "Flow_3dDcaGlobalPart", nDcaBins, dcaMin, glDcaMax);
+ fHistDcaGlobalPart = new TH1F("Flow_3dDcaGlobalPart", "Flow_3dDcaGlobalPart", kDcaBins, dcaMin, glDcaMax);
  fHistDcaGlobalPart->Sumw2();
  fHistDcaGlobalPart->SetXTitle("|3d Global Track's dca to Vertex (cm)|");
  fHistDcaGlobalPart->SetYTitle("Counts");
 
  // Distance of closest approach for particles NOT SELECTED for correlation with the event plane - 3d
- fHistDcaGlobalOut = new TH1F("Flow_3dDcaGlobalOut", "Flow_3dDcaGlobalOut", nDcaBins, dcaMin, glDcaMax);
+ fHistDcaGlobalOut = new TH1F("Flow_3dDcaGlobalOut", "Flow_3dDcaGlobalOut", kDcaBins, dcaMin, glDcaMax);
  fHistDcaGlobalOut->Sumw2();
  fHistDcaGlobalOut->SetXTitle("|3d Global Track's dca to Vertex (cm)|");
  fHistDcaGlobalOut->SetYTitle("Counts");
@@ -333,162 +333,162 @@ Bool_t AliFlowAnalyser::Init()
  
  // Chi2 
  // at the main vertex
- fHistChi2 = new TH1F("Flow_Chi2", "Flow_Chi2", nChi2Bins, chi2Min, chi2MaxC);
+ fHistChi2 = new TH1F("Flow_Chi2", "Flow_Chi2", kChi2Bins, chi2Min, chi2MaxC);
  fHistChi2->SetXTitle("Chi square at Main Vertex");
  fHistChi2->SetYTitle("Counts");
  // TPC
- fHistChi2TPC = new TH1F("Flow_Chi2_TPC", "Flow_Chi2_TPC", nChi2Bins, chi2Min, chi2Max);
+ fHistChi2TPC = new TH1F("Flow_Chi2_TPC", "Flow_Chi2_TPC", kChi2Bins, chi2Min, chi2Max);
  fHistChi2TPC->SetXTitle("Chi square for TPC");
  fHistChi2TPC->SetYTitle("Counts");
  // ITS
- fHistChi2ITS = new TH1F("Flow_Chi2_ITS", "Flow_Chi2_ITS", nChi2Bins, chi2Min, chi2MaxI);
+ fHistChi2ITS = new TH1F("Flow_Chi2_ITS", "Flow_Chi2_ITS", kChi2Bins, chi2Min, chi2MaxI);
  fHistChi2ITS->SetXTitle("Chi square for ITS");
  fHistChi2ITS->SetYTitle("Counts");
  // TRD
- fHistChi2TRD = new TH1F("Flow_Chi2_TRD", "Flow_Chi2_TRD", nChi2Bins, chi2Min, chi2Max);
+ fHistChi2TRD = new TH1F("Flow_Chi2_TRD", "Flow_Chi2_TRD", kChi2Bins, chi2Min, chi2Max);
  fHistChi2TRD->SetXTitle("Chi square for TRD");
  fHistChi2TRD->SetYTitle("Counts");
  // TOF
- fHistChi2TOF = new TH1F("Flow_Chi2_TOF", "Flow_Chi2_TOF", nChi2Bins, chi2Min, chi2Max);
+ fHistChi2TOF = new TH1F("Flow_Chi2_TOF", "Flow_Chi2_TOF", kChi2Bins, chi2Min, chi2Max);
  fHistChi2TOF->SetXTitle("Chi square for TOF");
  fHistChi2TOF->SetYTitle("Counts");
 
  // Chi2 normalized
  // TPC
- fHistChi2normTPC = new TH1F("Flow_Chi2norm_TPC", "Flow_Chi2norm_TPC", nChi2Bins, chi2Min, chi2normMax);
+ fHistChi2normTPC = new TH1F("Flow_Chi2norm_TPC", "Flow_Chi2norm_TPC", kChi2Bins, chi2Min, chi2normMax);
  fHistChi2normTPC->SetXTitle("Normalized #Chi^{2} for TPC");
  fHistChi2normTPC->SetYTitle("Counts");
  // ITS
- fHistChi2normITS = new TH1F("Flow_Chi2norm_ITS", "Flow_Chi2norm_ITS", nChi2Bins, chi2Min, chi2normMax);
+ fHistChi2normITS = new TH1F("Flow_Chi2norm_ITS", "Flow_Chi2norm_ITS", kChi2Bins, chi2Min, chi2normMax);
  fHistChi2normITS->SetXTitle("Normalized #Chi^{2} for ITS");
  fHistChi2normITS->SetYTitle("Counts");
  // TRD
- fHistChi2normTRD = new TH1F("Flow_Chi2norm_TRD", "Flow_Chi2norm_TRD", nChi2Bins, chi2Min, chi2normMax);
+ fHistChi2normTRD = new TH1F("Flow_Chi2norm_TRD", "Flow_Chi2norm_TRD", kChi2Bins, chi2Min, chi2normMax);
  fHistChi2normTRD->SetXTitle("Normalized #Chi^{2} for TRD");
  fHistChi2normTRD->SetYTitle("Counts");
  // TOF
- fHistChi2normTOF = new TH1F("Flow_Chi2norm_TOF", "Flow_Chi2norm_TOF", nChi2Bins, chi2Min, chi2normMax);
+ fHistChi2normTOF = new TH1F("Flow_Chi2norm_TOF", "Flow_Chi2norm_TOF", kChi2Bins, chi2Min, chi2normMax);
  fHistChi2normTOF->SetXTitle("Normalized #Chi^{2} for TOF");
  fHistChi2normTOF->SetYTitle("Counts");
  
  // FitPts
  // TPC
- fHistFitPtsTPC = new TH1F("Flow_FitPts_TPC", "Flow_FitPts_TPC", nFitPtsBinsTpc, fitPtsMin, fitPtsMaxTpc);
+ fHistFitPtsTPC = new TH1F("Flow_FitPts_TPC", "Flow_FitPts_TPC", kFitPtsBinsTpc, fitPtsMin, fitPtsMaxTpc);
  fHistFitPtsTPC->SetXTitle("Fit Points");
  fHistFitPtsTPC->SetYTitle("Counts");
  // ITS
- fHistFitPtsITS = new TH1F("Flow_HitPts_ITS", "Flow_HitPts_ITS", nFitPtsBinsIts, fitPtsMin, fitPtsMaxIts);
+ fHistFitPtsITS = new TH1F("Flow_HitPts_ITS", "Flow_HitPts_ITS", kFitPtsBinsIts, fitPtsMin, fitPtsMaxIts);
  fHistFitPtsITS->SetXTitle("Fit Points");
  fHistFitPtsITS->SetYTitle("Counts");
  // TRD
- fHistFitPtsTRD = new TH1F("Flow_FitPts_TRD", "Flow_FitPts_TRD", nFitPtsBinsTrd, fitPtsMin, fitPtsMaxTrd);
+ fHistFitPtsTRD = new TH1F("Flow_FitPts_TRD", "Flow_FitPts_TRD", kFitPtsBinsTrd, fitPtsMin, fitPtsMaxTrd);
  fHistFitPtsTRD->SetXTitle("Fit Points");
  fHistFitPtsTRD->SetYTitle("Counts");
  // TOF
- fHistFitPtsTOF = new TH1F("Flow_HitPts_TOF", "Flow_HitPts_TOF", nFitPtsBinsTof, fitPtsMin, fitPtsMaxTof);
+ fHistFitPtsTOF = new TH1F("Flow_HitPts_TOF", "Flow_HitPts_TOF", kFitPtsBinsTof, fitPtsMin, fitPtsMaxTof);
  fHistFitPtsTOF->SetXTitle("Fit Points");
  fHistFitPtsTOF->SetYTitle("Counts");
 
  // MaxPts 
  // TPC
- fHistMaxPtsTPC = new TH1F("Flow_MaxPts_TPC", "Flow_MaxPts_TPC", nFitPtsBinsTpc, fitPtsMin, fitPtsMaxTpc);
+ fHistMaxPtsTPC = new TH1F("Flow_MaxPts_TPC", "Flow_MaxPts_TPC", kFitPtsBinsTpc, fitPtsMin, fitPtsMaxTpc);
  fHistMaxPtsTPC->SetXTitle("Max Points");
  fHistMaxPtsTPC->SetYTitle("Counts");
  // ITS
- fHistMaxPtsITS = new TH1F("Flow_MaxPts_ITS", "Flow_MaxPts_ITS", nFitPtsBinsIts, fitPtsMin, fitPtsMaxIts);
+ fHistMaxPtsITS = new TH1F("Flow_MaxPts_ITS", "Flow_MaxPts_ITS", kFitPtsBinsIts, fitPtsMin, fitPtsMaxIts);
  fHistMaxPtsITS->SetXTitle("Max Points");
  fHistMaxPtsITS->SetYTitle("Counts");
  // TRD
- fHistMaxPtsTRD = new TH1F("Flow_MaxPts_TRD", "Flow_MaxPts_TRD", nFitPtsBinsTrd, fitPtsMin, fitPtsMaxTrd);
+ fHistMaxPtsTRD = new TH1F("Flow_MaxPts_TRD", "Flow_MaxPts_TRD", kFitPtsBinsTrd, fitPtsMin, fitPtsMaxTrd);
  fHistMaxPtsTRD->SetXTitle("Max Points");
  fHistMaxPtsTRD->SetYTitle("Counts");
  // TOF
- fHistMaxPtsTOF = new TH1F("Flow_MaxPts_TOF", "Flow_MaxPts_TOF", nFitPtsBinsTof, fitPtsMin, fitPtsMaxTof);
+ fHistMaxPtsTOF = new TH1F("Flow_MaxPts_TOF", "Flow_MaxPts_TOF", kFitPtsBinsTof, fitPtsMin, fitPtsMaxTof);
  fHistMaxPtsTOF->SetXTitle("Max Points");
  fHistMaxPtsTOF->SetYTitle("Counts");
 
  // FitOverMax 
  // Tpc
- fHistFitOverMaxTPC = new TH1F("Flow_FitOverMax_TPC", "Flow_FitOverMax_TPC", nFitOverMaxBins, fitOverMaxMin, fitOverMaxMax);
+ fHistFitOverMaxTPC = new TH1F("Flow_FitOverMax_TPC", "Flow_FitOverMax_TPC", kFitOverMaxBins, fitOverMaxMin, fitOverMaxMax);
  fHistFitOverMaxTPC->SetXTitle("(Fit Points - 1) / Max Points");
  fHistFitOverMaxTPC->SetYTitle("Counts");  
  // All
- fHistFitOverMax = new TH1F("Flow_FitOverMax", "Flow_FitOverMax", nFitOverMaxBins, fitOverMaxMin, fitOverMaxMax);
+ fHistFitOverMax = new TH1F("Flow_FitOverMax", "Flow_FitOverMax", kFitOverMaxBins, fitOverMaxMin, fitOverMaxMax);
  fHistFitOverMax->SetXTitle("(Fit Points - 1) / Max Points");
  fHistFitOverMax->SetYTitle("Counts");  
 
  // lenght
- fHistLenght = new TH1F("Flow_TrackLenght", "Flow_TrackLenght", nLgBins, lgMin, lgMax);
+ fHistLenght = new TH1F("Flow_TrackLenght", "Flow_TrackLenght", kLgBins, lgMin, lgMax);
  fHistLenght->SetXTitle("Lenght of the Track (cm)");
  fHistLenght->SetYTitle("Counts");
 
   // OrigMult
- fHistOrigMult = new TH1F("Flow_OrigMult", "Flow_OrigMult", nMultBins, multMin, multMax);
+ fHistOrigMult = new TH1F("Flow_OrigMult", "Flow_OrigMult", kMultBins, multMin, multMax);
  fHistOrigMult->SetXTitle("Original Mult");
  fHistOrigMult->SetYTitle("Counts");
 
  // MultEta
- fHistMultEta = new TH1F("Flow_MultEta", "Flow_MultEta", nMultBins, multMin, multMax);
+ fHistMultEta = new TH1F("Flow_MultEta", "Flow_MultEta", kMultBins, multMin, multMax);
  fHistMultEta->SetXTitle("Mult for Centrality");
  fHistMultEta->SetYTitle("Counts");
    
  // Mult
- fHistMult = new TH1F("Flow_Mult", "Flow_Mult", nMultBins, multMin, multMax);
+ fHistMult = new TH1F("Flow_Mult", "Flow_Mult", kMultBins, multMin, multMax);
  fHistMult->SetXTitle("Mult");
  fHistMult->SetYTitle("Counts");
 
  // V0s multiplicity
- fHistV0Mult = new TH1F("FlowV0_Mult","FlowV0_Mult", nMultBins, multMin, multV0);
+ fHistV0Mult = new TH1F("FlowV0_Mult","FlowV0_Mult", kMultBins, multMin, multV0);
  fHistV0Mult->SetXTitle("V0s Multiplicity");
  fHistV0Mult->SetYTitle("Counts");
    
  // MultOverOrig
- fHistMultOverOrig = new TH1F("Flow_MultOverOrig", "Flow_MultOverOrig", nMultOverOrigBins, multOverOrigMin, multOverOrigMax);
+ fHistMultOverOrig = new TH1F("Flow_MultOverOrig", "Flow_MultOverOrig", kMultOverOrigBins, multOverOrigMin, multOverOrigMax);
  fHistMultOverOrig->SetXTitle("Mult / Orig. Mult");
  fHistMultOverOrig->SetYTitle("Counts");
    
  // Mult correlated with the event planes
- fHistMultPart = new TH1F("Flow_MultPart", "Flow_MultPart", 2*nMultBins, multMin, multMax);
+ fHistMultPart = new TH1F("Flow_MultPart", "Flow_MultPart", 2*kMultBins, multMin, multMax);
  fHistMultPart->SetXTitle("Mult of Correlated Particles");
  fHistMultPart->SetYTitle("Counts");
    
  // Mult correlated with the event planes in 1 unit rapidity
- fHistMultPartUnit = new TH1F("Flow_MultPartUnit", "Flow_MultPartUnit", 2*nMultBins, multMin, multMax/2);
+ fHistMultPartUnit = new TH1F("Flow_MultPartUnit", "Flow_MultPartUnit", 2*kMultBins, multMin, multMax/2);
  fHistMultPartUnit->SetXTitle("Mult of Correlated Particles (-0.5 < eta < 0.5)");
  fHistMultPartUnit->SetYTitle("Counts");
    
  // Mult of V0s correlated with the event planes
- fHistV0MultPart = new TH1F("FlowV0_MultPart", "FlowV0_MultPart", nMultBins, multMin, multV0);
+ fHistV0MultPart = new TH1F("FlowV0_MultPart", "FlowV0_MultPart", kMultBins, multMin, multV0);
  fHistV0MultPart->SetXTitle("Mult of Correlated V0s");
  fHistV0MultPart->SetYTitle("Counts");
    
  // VertexZ
- fHistVertexZ = new TH1F("Flow_VertexZ", "Flow_VertexZ", nVertexZBins, vertexZMin, vertexZMax);
+ fHistVertexZ = new TH1F("Flow_VertexZ", "Flow_VertexZ", kVertexZBins, vertexZMin, vertexZMax);
  fHistVertexZ->SetXTitle("Vertex Z (cm)");
  fHistVertexZ->SetYTitle("Counts");
    
  // VertexXY
- fHistVertexXY2D = new TH2F("Flow_VertexXY2D", "Flow_VertexXY2D", nVertexXYBins, vertexXYMin, vertexXYMax, nVertexXYBins, vertexXYMin, vertexXYMax);
+ fHistVertexXY2D = new TH2F("Flow_VertexXY2D", "Flow_VertexXY2D", kVertexXYBins, vertexXYMin, vertexXYMax, kVertexXYBins, vertexXYMin, vertexXYMax);
  fHistVertexXY2D->SetXTitle("Vertex X (cm)");
  fHistVertexXY2D->SetYTitle("Vertex Y (cm)");
    
  // EtaSym vs. Vertex Z Tpc
- fHistEtaSymVerZ2D = new TH2F("Flow_EtaSymVerZ2D", "Flow_EtaSymVerZ2D", nVertexZBins, vertexZMin, vertexZMax, nEtaSymBins, etaSymMin, etaSymMax);
+ fHistEtaSymVerZ2D = new TH2F("Flow_EtaSymVerZ2D", "Flow_EtaSymVerZ2D", kVertexZBins, vertexZMin, vertexZMax, kEtaSymBins, etaSymMin, etaSymMax);
  fHistEtaSymVerZ2D->SetXTitle("Vertex Z (cm)");
  fHistEtaSymVerZ2D->SetYTitle("Eta Symmetry TPC");
 
  // EtaSym Tpc
- fHistEtaSym = new TH1F("Flow_EtaSym_TPC", "Flow_EtaSym_TPC", nEtaSymBins, etaSymMin, etaSymMax);
+ fHistEtaSym = new TH1F("Flow_EtaSym_TPC", "Flow_EtaSym_TPC", kEtaSymBins, etaSymMin, etaSymMax);
  fHistEtaSym->SetXTitle("Eta Symmetry Ratio TPC");
  fHistEtaSym->SetYTitle("Counts");
    
  // EtaSym vs. Vertex Z Tpc - correlation analysis
- fHistEtaSymVerZ2DPart = new TH2F("Flow_EtaSymVerZ2D_part", "Flow_EtaSymVerZ2D_part", nVertexZBins, vertexZMin, vertexZMax, nEtaSymBins, etaSymMinPart, etaSymMaxPart);
+ fHistEtaSymVerZ2DPart = new TH2F("Flow_EtaSymVerZ2D_part", "Flow_EtaSymVerZ2D_part", kVertexZBins, vertexZMin, vertexZMax, kEtaSymBins, etaSymMinPart, etaSymMaxPart);
  fHistEtaSymVerZ2DPart->SetXTitle("Vertex Z (cm)");
  fHistEtaSymVerZ2DPart->SetYTitle("Eta Symmetry TPC");
 
  // EtaSym Tpc - correlation analysis
- fHistEtaSymPart = new TH1F("Flow_EtaSym_TPC_part", "Flow_EtaSym_TPC_part", nEtaSymBins, etaSymMinPart, etaSymMaxPart);
+ fHistEtaSymPart = new TH1F("Flow_EtaSym_TPC_part", "Flow_EtaSym_TPC_part", kEtaSymBins, etaSymMinPart, etaSymMaxPart);
  fHistEtaSymPart->SetXTitle("Eta Symmetry Ratio TPC");
  fHistEtaSymPart->SetYTitle("Counts");
    
@@ -503,37 +503,37 @@ Bool_t AliFlowAnalyser::Init()
  fHistPhiCons->SetYTitle("Counts");
    
  // EtaPtPhi , whatever
- fHistAllEtaPtPhi3D = new TH3F("Flow_EtaPtPhi3Dall", "Flow_EtaPtPhi3Dall (whatever)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+ fHistAllEtaPtPhi3D = new TH3F("Flow_EtaPtPhi3Dall", "Flow_EtaPtPhi3Dall (whatever)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
  fHistAllEtaPtPhi3D->SetXTitle("Eta");
  fHistAllEtaPtPhi3D->SetYTitle("Pt (GeV/c)");
  fHistAllEtaPtPhi3D->SetZTitle("Phi (rad)");
    
  // Constrained EtaPtPhi
- fHistConsEtaPtPhi3D = new TH3F("Flow_consEtaPtPhi3D", "Flow_consEtaPtPhi3D (constrainable)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+ fHistConsEtaPtPhi3D = new TH3F("Flow_consEtaPtPhi3D", "Flow_consEtaPtPhi3D (constrainable)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
  fHistConsEtaPtPhi3D->SetXTitle("cEta");
  fHistConsEtaPtPhi3D->SetYTitle("cPt (GeV/c)");
  fHistConsEtaPtPhi3D->SetZTitle("cPhi (rad)");
    
  // Global EtaPtPhi
- fHistGlobEtaPtPhi3D = new TH3F("Flow_globEtaPtPhi3D", "Flow_globEtaPtPhi3D (constrainable)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+ fHistGlobEtaPtPhi3D = new TH3F("Flow_globEtaPtPhi3D", "Flow_globEtaPtPhi3D (constrainable)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
  fHistGlobEtaPtPhi3D->SetXTitle("gEta");
  fHistGlobEtaPtPhi3D->SetYTitle("gPt (GeV/c)");
  fHistGlobEtaPtPhi3D->SetZTitle("gPhi (rad)");
 
  // UnConstrained EtaPtPhi
- fHistUncEtaPtPhi3D = new TH3F("Flow_uncEtaPtPhi3D", "Flow_uncEtaPtPhi3D (un-constrainable)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+ fHistUncEtaPtPhi3D = new TH3F("Flow_uncEtaPtPhi3D", "Flow_uncEtaPtPhi3D (un-constrainable)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
  fHistUncEtaPtPhi3D->SetXTitle("gEta");
  fHistUncEtaPtPhi3D->SetYTitle("gPt (GeV/c)");
  fHistUncEtaPtPhi3D->SetZTitle("gPhi (rad)");
    
  // EtaPtPhi for particles correlated with the event plane
- fHistEtaPtPhi3DPart = new TH3F("Flow_EtaPtPhi3Dpart", "Flow_EtaPtPhi3Dpart (selected part)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+ fHistEtaPtPhi3DPart = new TH3F("Flow_EtaPtPhi3Dpart", "Flow_EtaPtPhi3Dpart (selected part)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
  fHistEtaPtPhi3DPart->SetXTitle("Eta");
  fHistEtaPtPhi3DPart->SetYTitle("Pt (GeV/c)");
  fHistEtaPtPhi3DPart->SetZTitle("Phi (rad)");
    
  // EtaPtPhi for particles NOT SELECTED for correlation with the event plane
- fHistEtaPtPhi3DOut = new TH3F("Flow_EtaPtPhi3Dout", "Flow_EtaPtPhi3Dout (NOT selected part)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+ fHistEtaPtPhi3DOut = new TH3F("Flow_EtaPtPhi3Dout", "Flow_EtaPtPhi3Dout (NOT selected part)", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
  fHistEtaPtPhi3DOut->SetXTitle("Eta");
  fHistEtaPtPhi3DOut->SetYTitle("Pt (GeV/c)");
  fHistEtaPtPhi3DOut->SetZTitle("Phi (rad)");
@@ -581,17 +581,17 @@ Bool_t AliFlowAnalyser::Init()
  fHistYieldOut2D->SetYTitle("Pt (GeV/c)");
  
  // invariant Mass for all particles (from TOF)
- fHistInvMass = new TH1F("Flow_InvMass", "Flow_InvMass (tof)", nMassBins, massMin, massMax);
+ fHistInvMass = new TH1F("Flow_InvMass", "Flow_InvMass (tof)", kMassBins, massMin, massMax);
  fHistInvMass->SetXTitle("Invariant Mass (GeV)");
  fHistInvMass->SetYTitle("Counts");
  
  // invariant Mass for particles correlated with the event plane (from TOF)
- fHistInvMassPart = new TH1F("Flow_InvMassPart", "Flow_InvMassPart (tof)", nMassBins, massMin, massMax);
+ fHistInvMassPart = new TH1F("Flow_InvMassPart", "Flow_InvMassPart (tof)", kMassBins, massMin, massMax);
  fHistInvMassPart->SetXTitle("Invariant Mass (GeV)");
  fHistInvMassPart->SetYTitle("Counts");
  
  // invariant Mass for particles NOT SELECTED for correlation with the event plane (from TOF)
- fHistInvMassOut = new TH1F("Flow_InvMassOut", "Flow_InvMassOut (tof)", nMassBins, massMin, massMax);
+ fHistInvMassOut = new TH1F("Flow_InvMassOut", "Flow_InvMassOut (tof)", kMassBins, massMin, massMax);
  fHistInvMassOut->SetXTitle("Invariant Mass (GeV)");
  fHistInvMassOut->SetYTitle("Counts");
 
@@ -606,127 +606,127 @@ Bool_t AliFlowAnalyser::Init()
  fHistBinPt->SetYTitle("<Pt> (GeV/c)");
  
  // cos(n*phiLab)
- fHistCosPhi = new TProfile("Flow_CosPhiLab", "Flow_CosPhiLab", Flow::nHars, 0.5, (float)(Flow::nHars) + 0.5, -100., 100., "");
+ fHistCosPhi = new TProfile("Flow_CosPhiLab", "Flow_CosPhiLab", AliFlowConstants::kHars, 0.5, (float)(AliFlowConstants::kHars) + 0.5, -100., 100., "");
  fHistCosPhi->SetXTitle("Harmonic");
  fHistCosPhi->SetYTitle("<cos(n*PhiLab)> (%)");
    
  // PID pi+
- fHistPidPiPlus = new TH1F("Flow_PidPiPlus", "Flow_PidPiPlus", nPidBins, pidMin, pidMax);
+ fHistPidPiPlus = new TH1F("Flow_PidPiPlus", "Flow_PidPiPlus", kPidBins, pidMin, pidMax);
  fHistPidPiPlus->SetXTitle("ALICE P.Id.");
  fHistPidPiPlus->SetYTitle("Counts");
    
  // PID pi-
- fHistPidPiMinus = new TH1F("Flow_PidPiMinus", "Flow_PidPiMinus", nPidBins, pidMin, pidMax);
+ fHistPidPiMinus = new TH1F("Flow_PidPiMinus", "Flow_PidPiMinus", kPidBins, pidMin, pidMax);
  fHistPidPiMinus->SetXTitle("ALICE P.Id.");
  fHistPidPiMinus->SetYTitle("Counts");
    
  // PID proton
- fHistPidProton = new TH1F("Flow_PidProton", "Flow_PidProton", nPidBins, pidMin, pidMax);
+ fHistPidProton = new TH1F("Flow_PidProton", "Flow_PidProton", kPidBins, pidMin, pidMax);
  fHistPidProton->SetXTitle("ALICE P.Id.");
  fHistPidProton->SetYTitle("Counts");
 
  // PID anti proton
- fHistPidAntiProton = new TH1F("Flow_PidAntiProton", "Flow_PidAntiProton", nPidBins, pidMin, pidMax);
+ fHistPidAntiProton = new TH1F("Flow_PidAntiProton", "Flow_PidAntiProton", kPidBins, pidMin, pidMax);
  fHistPidAntiProton->SetXTitle("ALICE P.Id.");
  fHistPidAntiProton->SetYTitle("Counts");
 
  // PID Kplus
- fHistPidKplus = new TH1F("Flow_PidKplus", "Flow_PidKplus", nPidBins, pidMin, pidMax);
+ fHistPidKplus = new TH1F("Flow_PidKplus", "Flow_PidKplus", kPidBins, pidMin, pidMax);
  fHistPidKplus->SetXTitle("ALICE P.Id.");
  fHistPidKplus->SetYTitle("Counts");
 
  // PID Kminus
- fHistPidKminus = new TH1F("Flow_PidKminus", "Flow_PidKminus", nPidBins, pidMin, pidMax);
+ fHistPidKminus = new TH1F("Flow_PidKminus", "Flow_PidKminus", kPidBins, pidMin, pidMax);
  fHistPidKminus->SetXTitle("ALICE P.Id.");
  fHistPidKminus->SetYTitle("Counts");
 
  // PID deuteron
- fHistPidDeuteron = new TH1F("Flow_PidDeuteron", "Flow_PidDeuteron", nPidBins, pidMin, pidMax);
+ fHistPidDeuteron = new TH1F("Flow_PidDeuteron", "Flow_PidDeuteron", kPidBins, pidMin, pidMax);
  fHistPidDeuteron->SetXTitle("ALICE P.Id.");
  fHistPidDeuteron->SetYTitle("Counts");
 
  // PID anti deuteron
- fHistPidAntiDeuteron = new TH1F("Flow_PidAntiDeuteron", "Flow_PidAntiDeuteron", nPidBins, pidMin, pidMax);
+ fHistPidAntiDeuteron = new TH1F("Flow_PidAntiDeuteron", "Flow_PidAntiDeuteron", kPidBins, pidMin, pidMax);
  fHistPidAntiDeuteron->SetXTitle("ALICE P.Id.");
  fHistPidAntiDeuteron->SetYTitle("Counts");
 
  // PID electron
- fHistPidElectron = new TH1F("Flow_PidElectron", "Flow_PidElectron", nPidBins, pidMin, pidMax);
+ fHistPidElectron = new TH1F("Flow_PidElectron", "Flow_PidElectron", kPidBins, pidMin, pidMax);
  fHistPidElectron->SetXTitle("ALICE P.Id.");
  fHistPidElectron->SetYTitle("Counts");
 
  // PID positron
- fHistPidPositron = new TH1F("Flow_PidPositron", "Flow_PidPositron", nPidBins, pidMin, pidMax);
+ fHistPidPositron = new TH1F("Flow_PidPositron", "Flow_PidPositron", kPidBins, pidMin, pidMax);
  fHistPidPositron->SetXTitle("ALICE P.Id.");
  fHistPidPositron->SetYTitle("Counts");
 
  // PID Muon+
- fHistPidMuonPlus = new TH1F("Flow_PidMuonPlus", "Flow_PidMuonPlus", nPidBins, pidMin, pidMax);
+ fHistPidMuonPlus = new TH1F("Flow_PidMuonPlus", "Flow_PidMuonPlus", kPidBins, pidMin, pidMax);
  fHistPidMuonPlus->SetXTitle("ALICE P.Id.");
  fHistPidMuonPlus->SetYTitle("Counts");
 
  // PID Muon-
- fHistPidMuonMinus = new TH1F("Flow_PidMuonMinus", "Flow_PidMuonMinus", nPidBins, pidMin, pidMax);
+ fHistPidMuonMinus = new TH1F("Flow_PidMuonMinus", "Flow_PidMuonMinus", kPidBins, pidMin, pidMax);
  fHistPidMuonMinus->SetXTitle("ALICE P.Id.");
  fHistPidMuonMinus->SetYTitle("Counts");
 
  // PID pi+ selected
- fHistPidPiPlusPart = new TH1F("Flow_PidPiPlusPart", "Flow_PidPiPlusPart", nPidBins, pidMin, pidMax);
+ fHistPidPiPlusPart = new TH1F("Flow_PidPiPlusPart", "Flow_PidPiPlusPart", kPidBins, pidMin, pidMax);
  fHistPidPiPlusPart->SetXTitle("ALICE P.Id. (pid = pi+)");
  fHistPidPiPlusPart->SetYTitle("Counts");
    
  // PID pi- selected
- fHistPidPiMinusPart = new TH1F("Flow_PidPiMinusPart", "Flow_PidPiMinusPart", nPidBins, pidMin, pidMax);
+ fHistPidPiMinusPart = new TH1F("Flow_PidPiMinusPart", "Flow_PidPiMinusPart", kPidBins, pidMin, pidMax);
  fHistPidPiMinusPart->SetXTitle("ALICE P.Id. (pid = pi-)");
  fHistPidPiMinusPart->SetYTitle("Counts");
    
  // PID proton selected
- fHistPidProtonPart = new TH1F("Flow_PidProtonPart", "Flow_PidProtonPart", nPidBins, pidMin, pidMax);
+ fHistPidProtonPart = new TH1F("Flow_PidProtonPart", "Flow_PidProtonPart", kPidBins, pidMin, pidMax);
  fHistPidProtonPart->SetXTitle("ALICE P.Id. (pid = p)");
  fHistPidProtonPart->SetYTitle("Counts");
 
  // PID anti proton selected
- fHistPidAntiProtonPart = new TH1F("Flow_PidAntiProtonPart", "Flow_PidAntiProtonPart", nPidBins, pidMin, pidMax);
+ fHistPidAntiProtonPart = new TH1F("Flow_PidAntiProtonPart", "Flow_PidAntiProtonPart", kPidBins, pidMin, pidMax);
  fHistPidAntiProtonPart->SetXTitle("ALICE P.Id. (pid = p-)");
  fHistPidAntiProtonPart->SetYTitle("Counts");
 
  // PID Kplus selected
- fHistPidKplusPart = new TH1F("Flow_PidKplusPart", "Flow_PidKplusPart", nPidBins, pidMin, pidMax);
+ fHistPidKplusPart = new TH1F("Flow_PidKplusPart", "Flow_PidKplusPart", kPidBins, pidMin, pidMax);
  fHistPidKplusPart->SetXTitle("ALICE P.Id. (pid = K+)");
  fHistPidKplusPart->SetYTitle("Counts");
 
  // PID Kminus selected
- fHistPidKminusPart = new TH1F("Flow_PidKminusPart", "Flow_PidKminusPart", nPidBins, pidMin, pidMax);
+ fHistPidKminusPart = new TH1F("Flow_PidKminusPart", "Flow_PidKminusPart", kPidBins, pidMin, pidMax);
  fHistPidKminusPart->SetXTitle("ALICE P.Id. (pid = K-)");
  fHistPidKminusPart->SetYTitle("Counts");
 
  // PID deuteron selected
- fHistPidDeuteronPart = new TH1F("Flow_PidDeuteronPart", "Flow_PidDeuteronPart", nPidBins, pidMin, pidMax);
+ fHistPidDeuteronPart = new TH1F("Flow_PidDeuteronPart", "Flow_PidDeuteronPart", kPidBins, pidMin, pidMax);
  fHistPidDeuteronPart->SetXTitle("ALICE P.Id. (pid = d)");
  fHistPidDeuteronPart->SetYTitle("Counts");
 
  // PID anti deuteron selected
- fHistPidAntiDeuteronPart = new TH1F("Flow_PidAntiDeuteronPart", "Flow_PidAntiDeuteronPart", nPidBins, pidMin, pidMax);
+ fHistPidAntiDeuteronPart = new TH1F("Flow_PidAntiDeuteronPart", "Flow_PidAntiDeuteronPart", kPidBins, pidMin, pidMax);
  fHistPidAntiDeuteronPart->SetXTitle("ALICE P.Id. (pid = d--)");
  fHistPidAntiDeuteronPart->SetYTitle("Counts");
 
  // PID electron selected
- fHistPidElectronPart = new TH1F("Flow_PidElectronPart", "Flow_PidElectronPart", nPidBins, pidMin, pidMax);
+ fHistPidElectronPart = new TH1F("Flow_PidElectronPart", "Flow_PidElectronPart", kPidBins, pidMin, pidMax);
  fHistPidElectronPart->SetXTitle("ALICE P.Id. (pid = e-)");
  fHistPidElectronPart->SetYTitle("Counts");
 
  // PID positron selected
- fHistPidPositronPart = new TH1F("Flow_PidPositronPart", "Flow_PidPositronPart", nPidBins, pidMin, pidMax);
+ fHistPidPositronPart = new TH1F("Flow_PidPositronPart", "Flow_PidPositronPart", kPidBins, pidMin, pidMax);
  fHistPidPositronPart->SetXTitle("ALICE P.Id. (pid = e+)");
  fHistPidPositronPart->SetYTitle("Counts");
 
  // PID Muon+ selected
- fHistPidMuonPlusPart = new TH1F("Flow_PidMuonPlusPart", "Flow_PidMuonPlusPart", nPidBins, pidMin, pidMax);
+ fHistPidMuonPlusPart = new TH1F("Flow_PidMuonPlusPart", "Flow_PidMuonPlusPart", kPidBins, pidMin, pidMax);
  fHistPidMuonPlusPart->SetXTitle("ALICE P.Id. (pid = mu+)");
  fHistPidMuonPlusPart->SetYTitle("Counts");
 
  // PID Muon- selected
- fHistPidMuonMinusPart = new TH1F("Flow_PidMuonMinusPart", "Flow_PidMuonMinusPart", nPidBins, pidMin, pidMax);
+ fHistPidMuonMinusPart = new TH1F("Flow_PidMuonMinusPart", "Flow_PidMuonMinusPart", kPidBins, pidMin, pidMax);
  fHistPidMuonMinusPart->SetXTitle("ALICE P.Id. (pid = mu-)");
  fHistPidMuonMinusPart->SetYTitle("Counts");
 
@@ -736,303 +736,303 @@ Bool_t AliFlowAnalyser::Init()
  fHistPidMult->SetYTitle("Multiplicity");
 
  // PID for all tracks
- fHistBayPidMult = new TH1F("Flow_BayPidMult","Flow_BayPidMult",Flow::nPid,-0.5,((float)Flow::nPid-0.5));
+ fHistBayPidMult = new TH1F("Flow_BayPidMult","Flow_BayPidMult",AliFlowConstants::kPid,-0.5,((float)AliFlowConstants::kPid-0.5));
  fHistBayPidMult->Sumw2() ;
  fHistBayPidMult->SetXTitle("e+/- , mu+/- , pi+/- , K+/- , p+/- , d+/- ");
  fHistBayPidMult->SetYTitle("Counts");
    
  // PID for particles correlated with the event plane
- fHistBayPidMultPart = new TH1F("Flow_BayPidMult_Part","Flow_BayPidMult_Part",Flow::nPid,-0.5,((float)Flow::nPid-0.5));
+ fHistBayPidMultPart = new TH1F("Flow_BayPidMult_Part","Flow_BayPidMult_Part",AliFlowConstants::kPid,-0.5,((float)AliFlowConstants::kPid-0.5));
  fHistBayPidMultPart->Sumw2() ;
  fHistBayPidMultPart->SetXTitle("e+/- , mu+/- , pi+/- , K+/- , p+/- , d+/- ");
  fHistBayPidMultPart->SetYTitle("Counts");
 
  // Centrality
- fHistCent = new TH1F("Flow_Cent", "Flow_Cent", nCentBins, centMin, centMax);
+ fHistCent = new TH1F("Flow_Cent", "Flow_Cent", kCentBins, centMin, centMax);
  fHistCent->SetXTitle("Centrality Bin");
  fHistCent->SetYTitle("Counts");
    
  // Deposited Energy in ZDC
- fHistEnergyZDC = new TH2F("Flow_ZDC_E", "Flow_ZDC_E", 3, 0., 3., nZDCeBins, ZDCeMin, ZDCeMax);
+ fHistEnergyZDC = new TH2F("Flow_ZDC_E", "Flow_ZDC_E", 3, 0., 3., kZDCeBins, zdceMin, zdceMax);
  fHistEnergyZDC->SetXTitle("neutron , proton , e.m.");
  fHistEnergyZDC->SetYTitle("ZDC energy");
 
  // Part. versus Energy in ZDC
- fHistPartZDC = new TH1F("Flow_ZDC_Participants", "Flow_ZDC_Participants", nZDCpartBins, ZDCpartMin, ZDCpartMax);
+ fHistPartZDC = new TH1F("Flow_ZDC_Participants", "Flow_ZDC_Participants", kZDCpartBins, zdcpartMin, zdcpartMax);
  fHistPartZDC->SetXTitle("ZDC part");
  fHistPartZDC->SetYTitle("Counts");
 
  // MeanDedxPos TPC
- fHistMeanDedxPos2D = new TH2F("Flow_MeanDedxPos2D_TPC","Flow_MeanDedxPos2D_TPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanDedxPos2D = new TH2F("Flow_MeanDedxPos2D_TPC","Flow_MeanDedxPos2D_TPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanDedxPos2D->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxPos2D->SetYTitle("mean dEdx (+)");
  
  // MeanDedxNeg TPC
- fHistMeanDedxNeg2D = new TH2F("Flow_MeanDedxNeg2D_TPC","Flow_MeanDedxNeg2D_TPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanDedxNeg2D = new TH2F("Flow_MeanDedxNeg2D_TPC","Flow_MeanDedxNeg2D_TPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanDedxNeg2D->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxNeg2D->SetYTitle("mean dEdx (-)");
 
  // MeanDedxPos ITS
- fHistMeanDedxPos2DITS = new TH2F("Flow_MeanDedxPos2D_ITS","Flow_MeanDedxPos2D_ITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanDedxPos2DITS = new TH2F("Flow_MeanDedxPos2D_ITS","Flow_MeanDedxPos2D_ITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanDedxPos2DITS->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxPos2DITS->SetYTitle("mean dEdx (+)");
  
  // MeanDedxNeg ITS
- fHistMeanDedxNeg2DITS = new TH2F("Flow_MeanDedxNeg2D_ITS","Flow_MeanDedxNeg2D_ITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanDedxNeg2DITS = new TH2F("Flow_MeanDedxNeg2D_ITS","Flow_MeanDedxNeg2D_ITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanDedxNeg2DITS->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxNeg2DITS->SetYTitle("mean dEdx (-)");
 
  // MeanDedxPos TPC 3D selected Part
- fHistMeanDedxPos3DPart = new TH3F("Flow_MeanDedxPos3DPart_TPC","Flow_MeanDedxPos3DPart_TPC", nMomenBins, logpMin, logpMax, nDedxBins, 0., dEdxMaxTPC, Flow::nPid, 0., Flow::nPid);
+ fHistMeanDedxPos3DPart = new TH3F("Flow_MeanDedxPos3DPart_TPC","Flow_MeanDedxPos3DPart_TPC", kMomenBins, logpMin, logpMax, kDedxBins, 0., dEdxMaxTPC, AliFlowConstants::kPid, 0., AliFlowConstants::kPid);
  fHistMeanDedxPos3DPart->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxPos3DPart->SetYTitle("mean dEdx (+)");
  fHistMeanDedxPos3DPart->SetZTitle("e , mu , pi , k , p , d");
  
  // MeanDedxNeg TPC 3D selected Part
- fHistMeanDedxNeg3DPart = new TH3F("Flow_MeanDedxNeg3DPart_TPC","Flow_MeanDedxNeg3DPart_TPC", nMomenBins, logpMin, logpMax, nDedxBins, 0., dEdxMaxTPC, Flow::nPid, 0., Flow::nPid);
+ fHistMeanDedxNeg3DPart = new TH3F("Flow_MeanDedxNeg3DPart_TPC","Flow_MeanDedxNeg3DPart_TPC", kMomenBins, logpMin, logpMax, kDedxBins, 0., dEdxMaxTPC, AliFlowConstants::kPid, 0., AliFlowConstants::kPid);
  fHistMeanDedxNeg3DPart->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxNeg3DPart->SetYTitle("mean dEdx (-)");
  fHistMeanDedxNeg3DPart->SetZTitle("e , mu , pi , k , p , d");
 
  // MeanDedxPos ITS 3D selected Part
- fHistMeanDedxPos3DPartITS = new TH3F("Flow_MeanDedxPos3DPart_ITS","Flow_MeanDedxPos3DPart_ITS", nMomenBins, logpMin, logpMax, nDedxBins, 0., dEdxMax, Flow::nPid, 0., Flow::nPid);
+ fHistMeanDedxPos3DPartITS = new TH3F("Flow_MeanDedxPos3DPart_ITS","Flow_MeanDedxPos3DPart_ITS", kMomenBins, logpMin, logpMax, kDedxBins, 0., dEdxMax, AliFlowConstants::kPid, 0., AliFlowConstants::kPid);
  fHistMeanDedxPos3DPartITS->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxPos3DPartITS->SetYTitle("mean dEdx (+)");
  fHistMeanDedxPos3DPartITS->SetZTitle("e , mu , pi , k , p , d");
  
  // MeanDedxNeg ITS 3D selected Part
- fHistMeanDedxNeg3DPartITS = new TH3F("Flow_MeanDedxNeg3DPart_ITS","Flow_MeanDedxNeg3DPart_ITS", nMomenBins, logpMin, logpMax, nDedxBins, 0., dEdxMax, Flow::nPid, 0., Flow::nPid);
+ fHistMeanDedxNeg3DPartITS = new TH3F("Flow_MeanDedxNeg3DPart_ITS","Flow_MeanDedxNeg3DPart_ITS", kMomenBins, logpMin, logpMax, kDedxBins, 0., dEdxMax, AliFlowConstants::kPid, 0., AliFlowConstants::kPid);
  fHistMeanDedxNeg3DPartITS->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxNeg3DPartITS->SetYTitle("mean dEdx (-)");
  fHistMeanDedxNeg3DPartITS->SetZTitle("e , mu , pi , k , p , d");
 
  // MeanSignalPos TRD
- fHistMeanDedxPos2DTRD = new TH2F("Flow_MeanSignalPos2D_TRD","Flow_MeanSignalPos2D_TRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanDedxPos2DTRD = new TH2F("Flow_MeanSignalPos2D_TRD","Flow_MeanSignalPos2D_TRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanDedxPos2DTRD->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxPos2DTRD->SetYTitle("mean TRD (+)");
  
  // MeanSignalNeg TRD
- fHistMeanDedxNeg2DTRD = new TH2F("Flow_MeanSignalNeg2D_TRD","Flow_MeanSignalNeg2D_TRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanDedxNeg2DTRD = new TH2F("Flow_MeanSignalNeg2D_TRD","Flow_MeanSignalNeg2D_TRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanDedxNeg2DTRD->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxNeg2DTRD->SetYTitle("mean TRD (-)");
 
  // MeanTimePos TOF
- fHistMeanDedxPos2DTOF = new TH2F("Flow_MeanTimePos2D_TOF","Flow_MeanTimePos2D_TOF", nMomenBins, logpMin, logpMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanDedxPos2DTOF = new TH2F("Flow_MeanTimePos2D_TOF","Flow_MeanTimePos2D_TOF", kMomenBins, logpMin, logpMax, kTofBins, tofmin, tofmax);
  fHistMeanDedxPos2DTOF->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxPos2DTOF->SetYTitle("mean Time of Flight (+)");
  
  // MeanTimeNeg TOF
- fHistMeanDedxNeg2DTOF = new TH2F("Flow_MeanTimeNeg2D_TOF","Flow_MeanTimeNeg2D_TOF", nMomenBins, logpMin, logpMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanDedxNeg2DTOF = new TH2F("Flow_MeanTimeNeg2D_TOF","Flow_MeanTimeNeg2D_TOF", kMomenBins, logpMin, logpMax, kTofBins, tofmin, tofmax);
  fHistMeanDedxNeg2DTOF->SetXTitle("log(momentum) (GeV/c)");
  fHistMeanDedxNeg2DTOF->SetYTitle("mean Time of Flight (-)");
  
  // Detector response for each particle { ... 
  // MeanDedx PiPlus - TPC
- fHistMeanTPCPiPlus = new TH2F("Flow_MeanDedxPiPlusTPC", "Flow_MeanDedxPiPlusTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCPiPlus = new TH2F("Flow_MeanDedxPiPlusTPC", "Flow_MeanDedxPiPlusTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCPiPlus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCPiPlus->SetYTitle("mean dEdx (pi+)");
  // MeanDedx PiMinus
- fHistMeanTPCPiMinus = new TH2F("Flow_MeanDedxPiMinusTPC", "Flow_MeanDedxPiMinusTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCPiMinus = new TH2F("Flow_MeanDedxPiMinusTPC", "Flow_MeanDedxPiMinusTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCPiMinus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCPiMinus->SetYTitle("mean dEdx (pi-)");
  // MeanDedx Proton
- fHistMeanTPCProton = new TH2F("Flow_MeanDedxProtonTPC", "Flow_MeanDedxProtonTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCProton = new TH2F("Flow_MeanDedxProtonTPC", "Flow_MeanDedxProtonTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCProton->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCProton->SetYTitle("mean dEdx (pr+)");
  // MeanDedx Pbar
- fHistMeanTPCPbar = new TH2F("Flow_MeanDedxPbarTPC", "Flow_MeanDedxPbarTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCPbar = new TH2F("Flow_MeanDedxPbarTPC", "Flow_MeanDedxPbarTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCPbar->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCPbar->SetYTitle("mean dEdx (pr-)");
  // MeanDedx Kplus
- fHistMeanTPCKplus = new TH2F("Flow_MeanDedxKplusTPC", "Flow_MeanDedxKplusTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCKplus = new TH2F("Flow_MeanDedxKplusTPC", "Flow_MeanDedxKplusTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCKplus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCKplus->SetYTitle("mean dEdx (K+)");
  // MeanDedx Kminus
- fHistMeanTPCKminus = new TH2F("Flow_MeanDedxKminusTPC", "Flow_MeanDedxKminusTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCKminus = new TH2F("Flow_MeanDedxKminusTPC", "Flow_MeanDedxKminusTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCKminus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCKminus->SetYTitle("mean dEdx (K-)");
  // MeanDedx Deuteron
- fHistMeanTPCDeuteron = new TH2F("Flow_MeanDedxDeuteronTPC", "Flow_MeanDedxDeuteronTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCDeuteron = new TH2F("Flow_MeanDedxDeuteronTPC", "Flow_MeanDedxDeuteronTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCDeuteron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCDeuteron->SetYTitle("mean dEdx (d+)");
  // MeanDedx AntiDeuteron
- fHistMeanTPCAntiDeuteron = new TH2F("Flow_MeanDedxAntiDeuteronTPC", "Flow_MeanDedxAntiDeuteronTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCAntiDeuteron = new TH2F("Flow_MeanDedxAntiDeuteronTPC", "Flow_MeanDedxAntiDeuteronTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCAntiDeuteron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCAntiDeuteron->SetYTitle("mean dEdx (d-)");
  // MeanDedxElectron
- fHistMeanTPCElectron = new TH2F("Flow_MeanDedxElectronTPC", "Flow_MeanDedxElectronTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCElectron = new TH2F("Flow_MeanDedxElectronTPC", "Flow_MeanDedxElectronTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCElectron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCElectron->SetYTitle("mean dEdx (e-)");
  // MeanDedx Positron
- fHistMeanTPCPositron = new TH2F("Flow_MeanDedxPositronTPC", "Flow_MeanDedxPositronTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCPositron = new TH2F("Flow_MeanDedxPositronTPC", "Flow_MeanDedxPositronTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCPositron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCPositron->SetYTitle("mean dEdx (e+)");
  // MeanDedx MuonPlus
- fHistMeanTPCMuonPlus = new TH2F("Flow_MeanDedxMuonPlusTPC", "Flow_MeanDedxMuonPlusTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCMuonPlus = new TH2F("Flow_MeanDedxMuonPlusTPC", "Flow_MeanDedxMuonPlusTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCMuonPlus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCMuonPlus->SetYTitle("mean dEdx (mu+)");
  // MeanDedx MuonMinus
- fHistMeanTPCMuonMinus = new TH2F("Flow_MeanDedxMuonMinusTPC", "Flow_MeanDedxMuonMinusTPC", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMaxTPC);
+ fHistMeanTPCMuonMinus = new TH2F("Flow_MeanDedxMuonMinusTPC", "Flow_MeanDedxMuonMinusTPC", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMaxTPC);
  fHistMeanTPCMuonMinus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTPCMuonMinus->SetYTitle("mean dEdx (mu-)");
  
  // MeanDedx PiPlus - ITS
- fHistMeanITSPiPlus = new TH2F("Flow_MeanDedxPiPlusITS", "Flow_MeanDedxPiPlusITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSPiPlus = new TH2F("Flow_MeanDedxPiPlusITS", "Flow_MeanDedxPiPlusITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSPiPlus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSPiPlus->SetYTitle("mean dEdx (pi+)");
  // MeanDedx PiMinus
- fHistMeanITSPiMinus = new TH2F("Flow_MeanDedxPiMinusITS", "Flow_MeanDedxPiMinusITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSPiMinus = new TH2F("Flow_MeanDedxPiMinusITS", "Flow_MeanDedxPiMinusITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSPiMinus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSPiMinus->SetYTitle("mean dEdx (pi-)");
  // MeanDedx Proton
- fHistMeanITSProton = new TH2F("Flow_MeanDedxProtonITS", "Flow_MeanDedxProtonITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSProton = new TH2F("Flow_MeanDedxProtonITS", "Flow_MeanDedxProtonITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSProton->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSProton->SetYTitle("mean dEdx (pr+)");
  // MeanDedx Pbar
- fHistMeanITSPbar = new TH2F("Flow_MeanDedxPbarITS", "Flow_MeanDedxPbarITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSPbar = new TH2F("Flow_MeanDedxPbarITS", "Flow_MeanDedxPbarITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSPbar->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSPbar->SetYTitle("mean dEdx (pr-)");
  // MeanDedx Kplus
- fHistMeanITSKplus = new TH2F("Flow_MeanDedxKplusITS", "Flow_MeanDedxKplusITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSKplus = new TH2F("Flow_MeanDedxKplusITS", "Flow_MeanDedxKplusITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSKplus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSKplus->SetYTitle("mean dEdx (K+)");
  // MeanDedx Kminus
- fHistMeanITSKminus = new TH2F("Flow_MeanDedxKminusITS", "Flow_MeanDedxKminusITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSKminus = new TH2F("Flow_MeanDedxKminusITS", "Flow_MeanDedxKminusITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSKminus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSKminus->SetYTitle("mean dEdx (K-)");
  // MeanDedx Deuteron
- fHistMeanITSDeuteron = new TH2F("Flow_MeanDedxDeuteronITS", "Flow_MeanDedxDeuteronITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSDeuteron = new TH2F("Flow_MeanDedxDeuteronITS", "Flow_MeanDedxDeuteronITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSDeuteron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSDeuteron->SetYTitle("mean dEdx (d+)");
  // MeanDedx AntiDeuteron
- fHistMeanITSAntiDeuteron = new TH2F("Flow_MeanDedxAntiDeuteronITS", "Flow_MeanDedxAntiDeuteronITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSAntiDeuteron = new TH2F("Flow_MeanDedxAntiDeuteronITS", "Flow_MeanDedxAntiDeuteronITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSAntiDeuteron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSAntiDeuteron->SetYTitle("mean dEdx (d-)");
  // MeanDedx Electron
- fHistMeanITSElectron = new TH2F("Flow_MeanDedxElectronITS", "Flow_MeanDedxElectronITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSElectron = new TH2F("Flow_MeanDedxElectronITS", "Flow_MeanDedxElectronITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSElectron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSElectron->SetYTitle("mean dEdx (e-)");
  // MeanDedx Positron
- fHistMeanITSPositron = new TH2F("Flow_MeanDedxPositronITS", "Flow_MeanDedxPositronITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSPositron = new TH2F("Flow_MeanDedxPositronITS", "Flow_MeanDedxPositronITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSPositron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSPositron->SetYTitle("mean dEdx (e+)");
  // MeanDedx MuonPlus
- fHistMeanITSMuonPlus = new TH2F("Flow_MeanDedxMuonPlusITS", "Flow_MeanDedxMuonPlusITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSMuonPlus = new TH2F("Flow_MeanDedxMuonPlusITS", "Flow_MeanDedxMuonPlusITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSMuonPlus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSMuonPlus->SetYTitle("mean dEdx (mu+)");
  // MeanDedx MuonMinus
- fHistMeanITSMuonMinus = new TH2F("Flow_MeanDedxMuonMinusITS", "Flow_MeanDedxMuonMinusITS", nMomenBins, logpMin, logpMax, nDedxBins, 0, dEdxMax);
+ fHistMeanITSMuonMinus = new TH2F("Flow_MeanDedxMuonMinusITS", "Flow_MeanDedxMuonMinusITS", kMomenBins, logpMin, logpMax, kDedxBins, 0, dEdxMax);
  fHistMeanITSMuonMinus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanITSMuonMinus->SetYTitle("mean dEdx (mu-)");
  
  // MeanTrd PiPlus - TRD
- fHistMeanTRDPiPlus = new TH2F("Flow_MeanTrdPiPlusTRD", "Flow_MeanTrdPiPlusTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDPiPlus = new TH2F("Flow_MeanTrdPiPlusTRD", "Flow_MeanTrdPiPlusTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDPiPlus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDPiPlus->SetYTitle("mean t.r.[] (pi+)");
  // MeanTrd PiMinus
- fHistMeanTRDPiMinus = new TH2F("Flow_MeanTrdPiMinusTRD", "Flow_MeanTrdPiMinusTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDPiMinus = new TH2F("Flow_MeanTrdPiMinusTRD", "Flow_MeanTrdPiMinusTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDPiMinus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDPiMinus->SetYTitle("mean t.r.[] (pi-)");
  // MeanTrd Proton
- fHistMeanTRDProton = new TH2F("Flow_MeanTrdProtonTRD", "Flow_MeanTrdProtonTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDProton = new TH2F("Flow_MeanTrdProtonTRD", "Flow_MeanTrdProtonTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDProton->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDProton->SetYTitle("mean t.r.[] (pr+)");
  // MeanTrd Pbar
- fHistMeanTRDPbar = new TH2F("Flow_MeanTrdPbarTRD", "Flow_MeanTrdPbarTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDPbar = new TH2F("Flow_MeanTrdPbarTRD", "Flow_MeanTrdPbarTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDPbar->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDPbar->SetYTitle("mean t.r.[] (pr-)");
  // MeanTrd Kplus
- fHistMeanTRDKplus = new TH2F("Flow_MeanTrdKplusTRD", "Flow_MeanTrdKplusTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDKplus = new TH2F("Flow_MeanTrdKplusTRD", "Flow_MeanTrdKplusTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDKplus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDKplus->SetYTitle("mean t.r.[] (K+)");
  // MeanTrd Kminus
- fHistMeanTRDKminus = new TH2F("Flow_MeanTrdKminusTRD", "Flow_MeanTrdKminusTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDKminus = new TH2F("Flow_MeanTrdKminusTRD", "Flow_MeanTrdKminusTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDKminus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDKminus->SetYTitle("mean t.r.[] (K-)");
  // MeanTrd Deuteron
- fHistMeanTRDDeuteron = new TH2F("Flow_MeanTrdDeuteronTRD", "Flow_MeanTrdDeuteronTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDDeuteron = new TH2F("Flow_MeanTrdDeuteronTRD", "Flow_MeanTrdDeuteronTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDDeuteron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDDeuteron->SetYTitle("mean t.r.[] (d+)");
  // MeanTrd AntiDeuteron
- fHistMeanTRDAntiDeuteron = new TH2F("Flow_MeanTrdAntiDeuteronTRD", "Flow_MeanTrdAntiDeuteronTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDAntiDeuteron = new TH2F("Flow_MeanTrdAntiDeuteronTRD", "Flow_MeanTrdAntiDeuteronTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDAntiDeuteron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDAntiDeuteron->SetYTitle("mean t.r.[] (d-)");
  // MeanTrd Electron
- fHistMeanTRDElectron = new TH2F("Flow_MeanTrdElectronTRD", "Flow_MeanTrdElectronTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDElectron = new TH2F("Flow_MeanTrdElectronTRD", "Flow_MeanTrdElectronTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDElectron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDElectron->SetYTitle("mean t.r.[] (e-)");
  // MeanTrd Positron
- fHistMeanTRDPositron = new TH2F("Flow_MeanTrdPositronTRD", "Flow_MeanTrdPositronTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDPositron = new TH2F("Flow_MeanTrdPositronTRD", "Flow_MeanTrdPositronTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDPositron->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDPositron->SetYTitle("mean t.r.[] (e+)");
  // MeanTrd MuonPlus
- fHistMeanTRDMuonPlus = new TH2F("Flow_MeanTrdMuonPlusTRD", "Flow_MeanTrdMuonPlusTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDMuonPlus = new TH2F("Flow_MeanTrdMuonPlusTRD", "Flow_MeanTrdMuonPlusTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDMuonPlus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDMuonPlus->SetYTitle("mean t.r.[] (mu+)");
  // MeanTrd MuonMinus
- fHistMeanTRDMuonMinus = new TH2F("Flow_MeanTrdMuonMinusTRD", "Flow_MeanTrdMuonMinusTRD", nMomenBins, logpMin, logpMax, nTrdBins, 0, TRDmax);
+ fHistMeanTRDMuonMinus = new TH2F("Flow_MeanTrdMuonMinusTRD", "Flow_MeanTrdMuonMinusTRD", kMomenBins, logpMin, logpMax, kTrdBins, 0, trdmax);
  fHistMeanTRDMuonMinus->SetXTitle("Log10(p) (GeV/c)");
  fHistMeanTRDMuonMinus->SetYTitle("mean t.r.[] (mu-)");
  
  // T.O.F. PiPlus - TOF
- fHistMeanTOFPiPlus = new TH2F("Flow_MeanTofPiPlusTOF", "Flow_MeanTofPiPlusTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFPiPlus = new TH2F("Flow_MeanTofPiPlusTOF", "Flow_MeanTofPiPlusTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFPiPlus->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFPiPlus->SetYTitle("mean t.o.f.[psec] (pi+)");
  // MeanTof PiMinus
- fHistMeanTOFPiMinus = new TH2F("Flow_MeanTofPiMinusTOF", "Flow_MeanTofPiMinusTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFPiMinus = new TH2F("Flow_MeanTofPiMinusTOF", "Flow_MeanTofPiMinusTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFPiMinus->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFPiMinus->SetYTitle("mean t.o.f.[psec] (pi-)");
  // MeanTof Proton
- fHistMeanTOFProton = new TH2F("Flow_MeanTofProtonTOF", "Flow_MeanTofProtonTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFProton = new TH2F("Flow_MeanTofProtonTOF", "Flow_MeanTofProtonTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFProton->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFProton->SetYTitle("mean t.o.f.[psec] (pr+)");
  // Mean TofPbar
- fHistMeanTOFPbar = new TH2F("Flow_MeanTofPbarTOF", "Flow_MeanTofPbarTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFPbar = new TH2F("Flow_MeanTofPbarTOF", "Flow_MeanTofPbarTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFPbar->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFPbar->SetYTitle("mean t.o.f.[psec] (pr-)");
  // mean t.o.f.[psec]Kplus
- fHistMeanTOFKplus = new TH2F("Flow_MeanTofKplusTOF", "Flow_MeanTofKplusTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFKplus = new TH2F("Flow_MeanTofKplusTOF", "Flow_MeanTofKplusTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFKplus->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFKplus->SetYTitle("mean t.o.f.[psec] (K+)");
  // mean t.o.f.[psec]Kminus
- fHistMeanTOFKminus = new TH2F("Flow_MeanTofKminusTOF", "Flow_MeanTofKminusTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFKminus = new TH2F("Flow_MeanTofKminusTOF", "Flow_MeanTofKminusTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFKminus->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFKminus->SetYTitle("mean t.o.f.[psec] (K-)");
  // MeanTof Deuteron
- fHistMeanTOFDeuteron = new TH2F("Flow_MeanTofDeuteronTOF", "Flow_MeanTofDeuteronTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFDeuteron = new TH2F("Flow_MeanTofDeuteronTOF", "Flow_MeanTofDeuteronTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFDeuteron->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFDeuteron->SetYTitle("mean t.o.f.[psec] (d+)");
  // MeanTof AntiDeuteron
- fHistMeanTOFAntiDeuteron = new TH2F("Flow_MeanTofAntiDeuteronTOF", "Flow_MeanTofAntiDeuteronTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFAntiDeuteron = new TH2F("Flow_MeanTofAntiDeuteronTOF", "Flow_MeanTofAntiDeuteronTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFAntiDeuteron->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFAntiDeuteron->SetYTitle("mean t.o.f.[psec] (d-)");
  // MeanTof Electron
- fHistMeanTOFElectron = new TH2F("Flow_MeanTofElectronTOF", "Flow_MeanTofElectronTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFElectron = new TH2F("Flow_MeanTofElectronTOF", "Flow_MeanTofElectronTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFElectron->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFElectron->SetYTitle("mean t.o.f.[psec] (e-)");
  // MeanTof Positron
- fHistMeanTOFPositron = new TH2F("Flow_MeanTofPositronTOF", "Flow_MeanTofPositronTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFPositron = new TH2F("Flow_MeanTofPositronTOF", "Flow_MeanTofPositronTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFPositron->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFPositron->SetYTitle("mean t.o.f.[psec] (e+)");
  // MeanTof MuonPlus
- fHistMeanTOFMuonPlus = new TH2F("Flow_MeanTofMuonPlusTOF", "Flow_MeanTofMuonPlusTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFMuonPlus = new TH2F("Flow_MeanTofMuonPlusTOF", "Flow_MeanTofMuonPlusTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFMuonPlus->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFMuonPlus->SetYTitle("mean t.o.f.[psec] (mu+)");
  // MeanTof MuonMinus
- fHistMeanTOFMuonMinus = new TH2F("Flow_MeanTofMuonMinusTOF", "Flow_MeanTofMuonMinusTOF", nMassBins, massMin, massMax, nTofBins, TOFmin, TOFmax);
+ fHistMeanTOFMuonMinus = new TH2F("Flow_MeanTofMuonMinusTOF", "Flow_MeanTofMuonMinusTOF", kMassBins, massMin, massMax, kTofBins, tofmin, tofmax);
  fHistMeanTOFMuonMinus->SetXTitle("invariant mass (GeV)");
  fHistMeanTOFMuonMinus->SetYTitle("mean t.o.f.[psec] (mu-)");
  // ... }
 
  TString* histTitle;
- for (int n = 0; n < Flow::nSubs; n++) // for sub-events
+ for (int n = 0; n < AliFlowConstants::kSubs; n++) // for sub-events
  {
-  for (int k = 0; k < Flow::nSels; k++) 
+  for (int k = 0; k < AliFlowConstants::kSels; k++) 
   {
-   for (int j = 0; j < Flow::nHars; j++) 
+   for (int j = 0; j < AliFlowConstants::kHars; j++) 
    {
     float order = (float)(j + 1);
-    int i = Flow::nSubs * k + n ;
+    int i = AliFlowConstants::kSubs * k + n ;
 
     // event planes
     histTitle = new TString("Flow_Psi_Sub");
@@ -1041,7 +1041,7 @@ Bool_t AliFlowAnalyser::Init()
     *histTitle += k+1;
     histTitle->Append("_Har");
     *histTitle += j+1;
-    fHistSub[i].fHistSubHar[j].fHistPsiSubs = new TH1F(histTitle->Data(),histTitle->Data(), nPsiBins, psiMin, (psiMax / order));
+    fHistSub[i].fHistSubHar[j].fHistPsiSubs = new TH1F(histTitle->Data(),histTitle->Data(), kPsiBins, psiMin, (psiMax / order));
     fHistSub[i].fHistSubHar[j].fHistPsiSubs->SetXTitle("Event Plane Angle (rad)");
     fHistSub[i].fHistSubHar[j].fHistPsiSubs->SetYTitle("Counts");
     delete histTitle;
@@ -1052,27 +1052,27 @@ Bool_t AliFlowAnalyser::Init()
  if(fV0loop)            // All V0s (if there, if flag on)
  {
  // Mass
-  fHistV0Mass = new TH1F("FlowV0_InvMass", "FlowV0_InvMass", nMassBins, massMin, massMax);
+  fHistV0Mass = new TH1F("FlowV0_InvMass", "FlowV0_InvMass", kMassBins, massMin, massMax);
   fHistV0Mass->SetXTitle("Invariant Mass (GeV)");
   fHistV0Mass->SetYTitle("Counts");
  // Distance of closest approach
-  fHistV0Dca = new TH1F("FlowV0_Dca", "FlowV0_Dca", nDcaBins, dcaMin, glDcaMax);
+  fHistV0Dca = new TH1F("FlowV0_Dca", "FlowV0_Dca", kDcaBins, dcaMin, glDcaMax);
   fHistV0Dca->SetXTitle("dca between tracks (cm)");
   fHistV0Dca->SetYTitle("Counts");
  // lenght
-  fHistV0Lenght = new TH1F("FlowV0_Lenght", "FlowV0_Lenght", nLgBins, lgMinV0, lgMaxV0);
+  fHistV0Lenght = new TH1F("FlowV0_Lenght", "FlowV0_Lenght", kLgBins, lgMinV0, lgMaxV0);
   fHistV0Lenght->SetXTitle("Distance of V0s (cm)");
   fHistV0Lenght->SetYTitle("Counts");
  // Sigma for all particles
-  fHistV0Sigma = new TH1F("FlowV0_Sigma", "FlowV0_Sigma", nLgBins, lgMinV0, lgMaxV0 );
+  fHistV0Sigma = new TH1F("FlowV0_Sigma", "FlowV0_Sigma", kLgBins, lgMinV0, lgMaxV0 );
   fHistV0Sigma->SetXTitle("Sigma");
   fHistV0Sigma->SetYTitle("Counts");
  // Chi2 
-  fHistV0Chi2 = new TH1F("FlowV0_Chi2", "FlowV0_Chi2", nChi2Bins, chi2Min, chi2MaxC);
+  fHistV0Chi2 = new TH1F("FlowV0_Chi2", "FlowV0_Chi2", kChi2Bins, chi2Min, chi2MaxC);
   fHistV0Chi2->SetXTitle("Chi square at Main Vertex");
   fHistV0Chi2->SetYTitle("Counts");
  // EtaPtPhi
-  fHistV0EtaPtPhi3D = new TH3F("FlowV0_EtaPtPhi3D", "FlowV0_EtaPtPhi3D", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+  fHistV0EtaPtPhi3D = new TH3F("FlowV0_EtaPtPhi3D", "FlowV0_EtaPtPhi3D", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
   fHistV0EtaPtPhi3D->SetXTitle("Eta");
   fHistV0EtaPtPhi3D->SetYTitle("Pt (GeV/c)");
   fHistV0EtaPtPhi3D->SetZTitle("Phi (rad)");
@@ -1082,7 +1082,7 @@ Bool_t AliFlowAnalyser::Init()
   fHistV0YieldAll2D->SetXTitle("Pseudorapidty");
   fHistV0YieldAll2D->SetYTitle("Pt (GeV/c)");
  // Mass slices on pT
-  fHistV0MassPtSlices = new TH2D("FlowV0_MassPtSlices", "FlowV0_MassPtSlices", nMassBins, massMin, massMax, fPtBins, fPtMin, fPtMax);
+  fHistV0MassPtSlices = new TH2D("FlowV0_MassPtSlices", "FlowV0_MassPtSlices", kMassBins, massMin, massMax, fPtBins, fPtMin, fPtMax);
   fHistV0MassPtSlices->Sumw2();
   fHistV0MassPtSlices->SetXTitle("Invariant Mass (GeV)");
   fHistV0MassPtSlices->SetYTitle("Pt (GeV/c)");
@@ -1099,39 +1099,39 @@ Bool_t AliFlowAnalyser::Init()
   fHistV0YieldPart2D->SetXTitle("Pseudorapidty");
   fHistV0YieldPart2D->SetYTitle("Pt (GeV/c)");
  // Mass Window
-  fHistV0MassWin = new TH1F("FlowV0_MassWinPart", "FlowV0_MassWinPart", nMassBins, massMin, massMax);
+  fHistV0MassWin = new TH1F("FlowV0_MassWinPart", "FlowV0_MassWinPart", kMassBins, massMin, massMax);
   fHistV0MassWin->SetXTitle("Invariant Mass (GeV)");
   fHistV0MassWin->SetYTitle("Counts");
  // EtaPtPhi
-  fHistV0EtaPtPhi3DPart = new TH3F("FlowV0_EtaPtPhi3Dpart", "FlowV0_EtaPtPhi3Dpart", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+  fHistV0EtaPtPhi3DPart = new TH3F("FlowV0_EtaPtPhi3Dpart", "FlowV0_EtaPtPhi3Dpart", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
   fHistV0EtaPtPhi3DPart->SetXTitle("Eta");
   fHistV0EtaPtPhi3DPart->SetYTitle("Pt (GeV/c)");
   fHistV0EtaPtPhi3DPart->SetZTitle("Phi (rad)");
  // Distance of closest approach
-  fHistV0DcaPart = new TH1F("FlowV0_DcaPart", "FlowV0_DcaPart", nDcaBins, dcaMin, dcaMax);
+  fHistV0DcaPart = new TH1F("FlowV0_DcaPart", "FlowV0_DcaPart", kDcaBins, dcaMin, dcaMax);
   fHistV0DcaPart->Sumw2();
   fHistV0DcaPart->SetXTitle("dca between tracks (cm)");
   fHistV0DcaPart->SetYTitle("Counts");
  // lenght
-  fHistV0LenghtPart = new TH1F("FlowV0_LenghtPart", "FlowV0_LenghtPart", nLgBins, lgMinV0, lgMaxV0);
+  fHistV0LenghtPart = new TH1F("FlowV0_LenghtPart", "FlowV0_LenghtPart", kLgBins, lgMinV0, lgMaxV0);
   fHistV0LenghtPart->SetXTitle("Distance of V0s (cm)");
   fHistV0LenghtPart->SetYTitle("Counts");
  // SideBand Mass (sidebands)
-  fHistV0sbMassSide = new TH1F("FlowV0sb_MassWinSideBands", "FlowV0sb_MassWinSideBands", nMassBins, massMin, massMax);
+  fHistV0sbMassSide = new TH1F("FlowV0sb_MassWinSideBands", "FlowV0sb_MassWinSideBands", kMassBins, massMin, massMax);
   fHistV0sbMassSide->SetXTitle("Invariant Mass (GeV)");
   fHistV0sbMassSide->SetYTitle("Counts");
  // EtaPtPhi (sidebands)
-  fHistV0sbEtaPtPhi3DPart = new TH3F("FlowV0sb_EtaPtPhi3D", "FlowV0sb_EtaPtPhi3D", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+  fHistV0sbEtaPtPhi3DPart = new TH3F("FlowV0sb_EtaPtPhi3D", "FlowV0sb_EtaPtPhi3D", fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
   fHistV0sbEtaPtPhi3DPart->SetXTitle("Eta");
   fHistV0sbEtaPtPhi3DPart->SetYTitle("Pt (GeV/c)");
   fHistV0sbEtaPtPhi3DPart->SetZTitle("Phi (rad)");
  // Distance of closest approach (sidebands)
-  fHistV0sbDcaPart = new TH1F("FlowV0sb_Dca", "FlowV0sb_Dca", nDcaBins, dcaMin, dcaMax);
+  fHistV0sbDcaPart = new TH1F("FlowV0sb_Dca", "FlowV0sb_Dca", kDcaBins, dcaMin, dcaMax);
   fHistV0sbDcaPart->Sumw2();
   fHistV0sbDcaPart->SetXTitle("dca between tracks (cm)");
   fHistV0sbDcaPart->SetYTitle("Counts");
  // lenght (sidebands)
-  fHistV0sbLenghtPart = new TH1F("FlowV0sb_Lenght", "FlowV0sb_Lenght", nLgBins, lgMinV0, lgMaxV0);
+  fHistV0sbLenghtPart = new TH1F("FlowV0sb_Lenght", "FlowV0sb_Lenght", kLgBins, lgMinV0, lgMaxV0);
   fHistV0sbLenghtPart->SetXTitle("Distance of V0s (cm)");
   fHistV0sbLenghtPart->SetYTitle("Counts");
 
@@ -1153,12 +1153,12 @@ Bool_t AliFlowAnalyser::Init()
   fHistV0sbBinPt->SetYTitle("<Pt> (GeV/c)");
  }
 
- for (int k = 0; k < Flow::nSels; k++) // for each selection
+ for (int k = 0; k < AliFlowConstants::kSels; k++) // for each selection
  {
   // cos(n*delta_Psi)
   histTitle = new TString("Flow_Cos_Sel");
   *histTitle += k+1;
-  fHistFull[k].fHistCos = new TProfile(histTitle->Data(), histTitle->Data(), Flow::nHars, 0.5, (float)(Flow::nHars) + 0.5, -1., 1., "");
+  fHistFull[k].fHistCos = new TProfile(histTitle->Data(), histTitle->Data(), AliFlowConstants::kHars, 0.5, (float)(AliFlowConstants::kHars) + 0.5, -1., 1., "");
   fHistFull[k].fHistCos->SetXTitle("Harmonic");
   fHistFull[k].fHistCos->SetYTitle("<cos(n*delta_Psi)>");
   delete histTitle;
@@ -1166,7 +1166,7 @@ Bool_t AliFlowAnalyser::Init()
   // resolution
   histTitle = new TString("Flow_Res_Sel");
   *histTitle += k+1;
-  fHistFull[k].fHistRes = new TH1F(histTitle->Data(), histTitle->Data(), Flow::nHars, 0.5, (float)(Flow::nHars) + 0.5);
+  fHistFull[k].fHistRes = new TH1F(histTitle->Data(), histTitle->Data(), AliFlowConstants::kHars, 0.5, (float)(AliFlowConstants::kHars) + 0.5);
   fHistFull[k].fHistRes->SetXTitle("Harmonic");
   fHistFull[k].fHistRes->SetYTitle("Resolution");
   delete histTitle;
@@ -1174,7 +1174,7 @@ Bool_t AliFlowAnalyser::Init()
   // vObs
   histTitle = new TString("Flow_vObs_Sel");
   *histTitle += k+1;
-  fHistFull[k].fHistvObs = new TProfile(histTitle->Data(), histTitle->Data(), Flow::nHars, 0.5, (float)(Flow::nHars) + 0.5, -100., 100., "");
+  fHistFull[k].fHistvObs = new TProfile(histTitle->Data(), histTitle->Data(), AliFlowConstants::kHars, 0.5, (float)(AliFlowConstants::kHars) + 0.5, -100., 100., "");
   fHistFull[k].fHistvObs->SetXTitle("Harmonic");
   fHistFull[k].fHistvObs->SetYTitle("vObs (%)");
   delete histTitle;
@@ -1182,7 +1182,7 @@ Bool_t AliFlowAnalyser::Init()
   // vObs V0
   histTitle = new TString("FlowV0_vObs_Sel");
   *histTitle += k+1;
-  fHistFull[k].fHistV0vObs = new TProfile(histTitle->Data(), histTitle->Data(), Flow::nHars, 0.5, (float)(Flow::nHars) + 0.5, -100., 100., "");
+  fHistFull[k].fHistV0vObs = new TProfile(histTitle->Data(), histTitle->Data(), AliFlowConstants::kHars, 0.5, (float)(AliFlowConstants::kHars) + 0.5, -100., 100., "");
   fHistFull[k].fHistV0vObs->SetXTitle("Harmonic");
   fHistFull[k].fHistV0vObs->SetYTitle("vObs (%)");
   delete histTitle;
@@ -1190,7 +1190,7 @@ Bool_t AliFlowAnalyser::Init()
   // vObs V0 sideband SX
   histTitle = new TString("FlowV0sb_vObs_sx_Sel");
   *histTitle += k+1;
-  fHistFull[k].fHistV0sbvObsSx = new TProfile(histTitle->Data(), histTitle->Data(), Flow::nHars, 0.5, (float)(Flow::nHars) + 0.5, -100., 100., "");
+  fHistFull[k].fHistV0sbvObsSx = new TProfile(histTitle->Data(), histTitle->Data(), AliFlowConstants::kHars, 0.5, (float)(AliFlowConstants::kHars) + 0.5, -100., 100., "");
   fHistFull[k].fHistV0sbvObsSx->SetXTitle("Harmonic");
   fHistFull[k].fHistV0sbvObsSx->SetYTitle("vObs (%)");
   delete histTitle;
@@ -1198,7 +1198,7 @@ Bool_t AliFlowAnalyser::Init()
   // vObs V0 sideband DX
   histTitle = new TString("FlowV0sb_vObs_dx_Sel");
   *histTitle += k+1;
-  fHistFull[k].fHistV0sbvObsDx = new TProfile(histTitle->Data(), histTitle->Data(), Flow::nHars, 0.5, (float)(Flow::nHars) + 0.5, -100., 100., "");
+  fHistFull[k].fHistV0sbvObsDx = new TProfile(histTitle->Data(), histTitle->Data(), AliFlowConstants::kHars, 0.5, (float)(AliFlowConstants::kHars) + 0.5, -100., 100., "");
   fHistFull[k].fHistV0sbvObsDx->SetXTitle("Harmonic");
   fHistFull[k].fHistV0sbvObsDx->SetYTitle("vObs (%)");
   delete histTitle;
@@ -1206,13 +1206,13 @@ Bool_t AliFlowAnalyser::Init()
   // PID for tracks used in R.P.
   histTitle = new TString("Flow_BayPidMult_Sel");
   *histTitle += k+1;
-  fHistFull[k].fHistBayPidMult = new TH1F(histTitle->Data(), histTitle->Data(),Flow::nPid,-0.5,((float)Flow::nPid-0.5));
+  fHistFull[k].fHistBayPidMult = new TH1F(histTitle->Data(), histTitle->Data(),AliFlowConstants::kPid,-0.5,((float)AliFlowConstants::kPid-0.5));
   fHistFull[k].fHistBayPidMult->Sumw2() ;
   fHistFull[k].fHistBayPidMult->SetXTitle("e+/-  ,  mu+/-  ,  pi+/-  ,  K+/-  ,  p+/-  ,  d+/- ");
   fHistFull[k].fHistBayPidMult->SetYTitle("Counts");
   delete histTitle;
 
-  for (int j = 0; j < Flow::nHars; j++)   // for each harmonic
+  for (int j = 0; j < AliFlowConstants::kHars; j++)   // for each harmonic
   {
    float order  = (float)(j+1);
 
@@ -1221,7 +1221,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistMult = new TH1F(histTitle->Data(),histTitle->Data(), nMultBins, multMin, multMax);
+   fHistFull[k].fHistFullHar[j].fHistMult = new TH1F(histTitle->Data(),histTitle->Data(), kMultBins, multMin, multMax);
    fHistFull[k].fHistFullHar[j].fHistMult->SetXTitle("Multiplicity");
    fHistFull[k].fHistFullHar[j].fHistMult->SetYTitle("Counts");
    delete histTitle;
@@ -1231,7 +1231,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistPsi = new TH1F(histTitle->Data(), histTitle->Data(), nPsiBins, psiMin, psiMax / order);
+   fHistFull[k].fHistFullHar[j].fHistPsi = new TH1F(histTitle->Data(), histTitle->Data(), kPsiBins, psiMin, psiMax / order);
    fHistFull[k].fHistFullHar[j].fHistPsi->SetXTitle("Event Plane Angle (rad)");
    fHistFull[k].fHistFullHar[j].fHistPsi->SetYTitle("Counts");
    delete histTitle;
@@ -1243,13 +1243,13 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += j+1;
    if (k == 0 ) 
    {
-    Int_t my_order = 1;
-    if (j == 1) { my_order = 2 ; }
-    fHistFull[k].fHistFullHar[j].fHistPsiDiff = new TH1F(histTitle->Data(), histTitle->Data(), nPsiBins, -psiMax/my_order/2., psiMax/my_order/2.);
+    Int_t myOrder = 1;
+    if (j == 1) { myOrder = 2 ; }
+    fHistFull[k].fHistFullHar[j].fHistPsiDiff = new TH1F(histTitle->Data(), histTitle->Data(), kPsiBins, -psiMax/myOrder/2., psiMax/myOrder/2.);
    } 
    else 
    {
-    fHistFull[k].fHistFullHar[j].fHistPsiDiff = new TH1F(histTitle->Data(), histTitle->Data(), nPsiBins, -psiMax/2., psiMax/2.);
+    fHistFull[k].fHistFullHar[j].fHistPsiDiff = new TH1F(histTitle->Data(), histTitle->Data(), kPsiBins, -psiMax/2., psiMax/2.);
    }
    if (k == 0) 
    {
@@ -1281,7 +1281,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistPsiSubCorr = new TH1F(histTitle->Data(), histTitle->Data(), nPsiBins, psiMin, psiMax / order);
+   fHistFull[k].fHistFullHar[j].fHistPsiSubCorr = new TH1F(histTitle->Data(), histTitle->Data(), kPsiBins, psiMin, psiMax / order);
    fHistFull[k].fHistFullHar[j].fHistPsiSubCorr->Sumw2();
    fHistFull[k].fHistFullHar[j].fHistPsiSubCorr->SetXTitle("Sub-Event Correlation (rad)");
    fHistFull[k].fHistFullHar[j].fHistPsiSubCorr->SetYTitle("Counts");
@@ -1292,7 +1292,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistPsiSubCorrDiff = new TH1F(histTitle->Data(), histTitle->Data(), nPsiBins, psiMin, psiMax / (order+1.));
+   fHistFull[k].fHistFullHar[j].fHistPsiSubCorrDiff = new TH1F(histTitle->Data(), histTitle->Data(), kPsiBins, psiMin, psiMax / (order+1.));
    fHistFull[k].fHistFullHar[j].fHistPsiSubCorrDiff->Sumw2();
    fHistFull[k].fHistFullHar[j].fHistPsiSubCorrDiff->SetXTitle("Sub-Event Correlation (rad)");
    fHistFull[k].fHistFullHar[j].fHistPsiSubCorrDiff->SetYTitle("Counts");
@@ -1303,7 +1303,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistQnorm = new TH1F(histTitle->Data(), histTitle->Data(), nQbins, qMin, qMax);
+   fHistFull[k].fHistFullHar[j].fHistQnorm = new TH1F(histTitle->Data(), histTitle->Data(), kQbins, qMin, qMax);
    fHistFull[k].fHistFullHar[j].fHistQnorm->Sumw2();
    fHistFull[k].fHistFullHar[j].fHistQnorm->SetXTitle("q = |Q|/sqrt(Mult)");
    fHistFull[k].fHistFullHar[j].fHistQnorm->SetYTitle("Counts");
@@ -1358,7 +1358,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3D = new TH3F(histTitle->Data(), histTitle->Data(), fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+   fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3D = new TH3F(histTitle->Data(), histTitle->Data(), fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
    fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3D->SetXTitle("Eta");
    fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3D->SetYTitle("Pt (GeV/c)");
    fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3D->SetZTitle("Phi (rad)");
@@ -1380,7 +1380,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistDcaGlob = new TH1F(histTitle->Data(), histTitle->Data(), nDcaBins, dcaMin, glDcaMax);
+   fHistFull[k].fHistFullHar[j].fHistDcaGlob = new TH1F(histTitle->Data(), histTitle->Data(), kDcaBins, dcaMin, glDcaMax);
    fHistFull[k].fHistFullHar[j].fHistDcaGlob->Sumw2();
    fHistFull[k].fHistFullHar[j].fHistDcaGlob->SetXTitle("|3d Global Track's dca to Vertex (cm)|");
    delete histTitle;
@@ -1401,7 +1401,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3Dout = new TH3F(histTitle->Data(), histTitle->Data(), fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, nPhi3DBins, fPhiMin, fPhiMax);
+   fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3Dout = new TH3F(histTitle->Data(), histTitle->Data(), fEtaBins, fEtaMin, fEtaMax, fPtBins, fPtMin, fPtMax, kPhi3DBins, fPhiMin, fPhiMax);
    fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3Dout->SetXTitle("Eta");
    fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3Dout->SetYTitle("Pt (GeV/c)");
    fHistFull[k].fHistFullHar[j].fHistEtaPtPhi3Dout->SetZTitle("Phi (rad)");
@@ -1423,7 +1423,7 @@ Bool_t AliFlowAnalyser::Init()
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   fHistFull[k].fHistFullHar[j].fHistDcaGlobout = new TH1F(histTitle->Data(), histTitle->Data(), nDcaBins, dcaMin, glDcaMax);
+   fHistFull[k].fHistFullHar[j].fHistDcaGlobout = new TH1F(histTitle->Data(), histTitle->Data(), kDcaBins, dcaMin, glDcaMax);
    fHistFull[k].fHistFullHar[j].fHistDcaGlobout->Sumw2();
    fHistFull[k].fHistFullHar[j].fHistDcaGlobout->SetXTitle("|3d Global Track's dca to Vertex (cm)|");
    delete histTitle;
@@ -1685,28 +1685,28 @@ Bool_t AliFlowAnalyser::Finish()
 //-----------------------------------------------------------------------
 // ###
 //----------------------------------------------------------------------
-Float_t AliFlowAnalyser::GetRunBayesian(Int_t nPid, Int_t selN)  
+Float_t AliFlowAnalyser::GetRunBayesian(Int_t nPid, Int_t selN) const 
 {
  // Returns the normalized particle abundance of "e","mu","pi","k","p","d"
  // in all the analysed events (in selection selN).
  // Call at the end of the analysis.
 
- if(selN>Flow::nSels) { selN = 0 ; }
+ if(selN>AliFlowConstants::kSels) { selN = 0 ; }
  Double_t totCount = (fHistFull[selN].fHistBayPidMult)->GetSumOfWeights() ;
  if(totCount) { return (fHistFull[selN].fHistBayPidMult->GetBinContent(nPid+1) / totCount) ; }
  else         { return 1. ; }
 }
 //-----------------------------------------------------------------------
-void AliFlowAnalyser::PrintRunBayesian(Int_t selN)  
+void AliFlowAnalyser::PrintRunBayesian(Int_t selN) const
 {
  // Prints the normalized particle abundance of all the analysed events 
  // (in selection selN).
 
- if(selN>Flow::nSels) { selN = 0 ; } 
- Char_t* names[Flow::nPid] = {"e","mu","pi","k","p","d"} ;
+ if(selN>AliFlowConstants::kSels) { selN = 0 ; } 
+ Char_t* names[AliFlowConstants::kPid] = {"e","mu","pi","k","p","d"} ;
  Double_t bayes = 0. ;
  cout << " selN = " << selN << " particles normalized abundance : " ;
- for(int i=0;i<Flow::nPid;i++)
+ for(int i=0;i<AliFlowConstants::kPid;i++)
  {
   bayes = GetRunBayesian(i, selN) ;
   cout << bayes << "_" << names[i] << " ; " ;
@@ -1725,32 +1725,32 @@ void AliFlowAnalyser::FillWgtArrays(TFile* wgtFile)
  fPhiWgtFile = wgtFile ;
 
  TString* histTitle ;
- TH1D* TPC_all ; TH1D* TPC_plus ; TH1D* TPC_minus ; TH1D* TPC_cross ;
- TH1D* PID_bay ;
- for(int k=0;k<Flow::nSels;k++)
+ TH1D* hTPCall ; TH1D* hTPCplus ; TH1D* hTPCminus ; TH1D* hTPCcross ;
+ TH1D* hPIDbay ;
+ for(int k=0;k<AliFlowConstants::kSels;k++)
  {
-  for(int j=0;j<Flow::nHars;j++) 
+  for(int j=0;j<AliFlowConstants::kHars;j++) 
   {
   // Tpc (plus)
    histTitle = new TString("Flow_Phi_Weight_TPCplus_Sel");
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   TPC_plus = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
+   hTPCplus = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
    delete histTitle;
    // Tpc (minus)
    histTitle = new TString("Flow_Phi_Weight_TPCminus_Sel");
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   TPC_minus = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
+   hTPCminus = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
    delete histTitle;
    // Tpc (cross)
    histTitle = new TString("Flow_Phi_Weight_TPCcross_Sel");
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   TPC_cross = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
+   hTPCcross = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
    delete histTitle;
 
    // Tpc
@@ -1758,15 +1758,15 @@ void AliFlowAnalyser::FillWgtArrays(TFile* wgtFile)
    *histTitle += k+1;
    histTitle->Append("_Har");
    *histTitle += j+1;
-   TPC_all = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
+   hTPCall = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
    delete histTitle;
 
    for(int n=0;n<fPhiBins;n++) 
    {
-    fPhiWgtPlus[k][j][n]  = TPC_plus->GetBinContent(n+1) ;
-    fPhiWgtMinus[k][j][n] = TPC_minus->GetBinContent(n+1) ;
-    fPhiWgtCross[k][j][n] = TPC_cross->GetBinContent(n+1) ;
-    fPhiWgt[k][j][n]     = TPC_all->GetBinContent(n+1) ;
+    fPhiWgtPlus[k][j][n]  = hTPCplus->GetBinContent(n+1) ;
+    fPhiWgtMinus[k][j][n] = hTPCminus->GetBinContent(n+1) ;
+    fPhiWgtCross[k][j][n] = hTPCcross->GetBinContent(n+1) ;
+    fPhiWgt[k][j][n]     = hTPCall->GetBinContent(n+1) ;
     // cout << "  Weights: " << fPhiWgt[k][j][n] << " ; " << fPhiWgtPlus[k][j][n] << " | " << fPhiWgtMinus[k][j][n] << " | " << fPhiWgtCross[k][j][n] << endl ; 
    }
   }
@@ -1774,19 +1774,19 @@ void AliFlowAnalyser::FillWgtArrays(TFile* wgtFile)
   // Bayesian weights
   histTitle = new TString("Flow_BayPidMult_Sel");
   *histTitle += k+1;
-  PID_bay = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
+  hPIDbay = (TH1D*)fPhiWgtFile->Get(histTitle->Data());
   delete histTitle;
-  Double_t totCount = PID_bay->GetSumOfWeights() ;
-  for (int n=0;n<Flow::nPid;n++) 
+  Double_t totCount = hPIDbay->GetSumOfWeights() ;
+  for (int n=0;n<AliFlowConstants::kPid;n++) 
   { 
-   if(totCount) { fBayesianWgt[k][n] = PID_bay->GetBinContent(n+1) / totCount ; }
+   if(totCount) { fBayesianWgt[k][n] = hPIDbay->GetBinContent(n+1) / totCount ; }
    else        { fBayesianWgt[k][n] = 1. ; }
    // cout << "  Bayesian Weights (" << n << ") : " << fBayesianWgt[k][n] << endl ; 
   }
  }
 
- delete TPC_all ; delete TPC_plus ; delete TPC_minus ; delete TPC_cross ;
- delete PID_bay ;
+ delete hTPCall ; delete hTPCplus ; delete hTPCminus ; delete hTPCcross ;
+ delete hPIDbay ;
 
  return ;
 }
@@ -1794,7 +1794,7 @@ void AliFlowAnalyser::FillWgtArrays(TFile* wgtFile)
 void AliFlowAnalyser::FillEvtPhiWgt(AliFlowEvent* fFlowEvent)
 {
  // Plugs phi weights into the static dwgt data member of the AliFlowEvent class.
- // Weights are given in special Flow::PhiWgt_t arrays (see AliFlowConstants), 
+ // Weights are given in special AliFlowConstants::PhiWgt_t arrays (see AliFlowConstants), 
  // which are read from the wgt histograms by the method FillWgtArrays(...).
  
  fFlowEvent->SetPhiWeight(fPhiWgt);
@@ -1813,9 +1813,9 @@ void AliFlowAnalyser::FillBayesianWgt(AliFlowEvent* fFlowEvent)
  // just the Selection n.0 (with no cuts) is used .
  // (AliFlowEvent::mBayesianCs[6] is a 1-dimensional array, change that first!).
 
- Double_t bayes[Flow::nPid] ; 
+ Double_t bayes[AliFlowConstants::kPid] ; 
  Double_t bayCheck = 0. ;
- for (int n=0;n<Flow::nPid;n++) 
+ for (int n=0;n<AliFlowConstants::kPid;n++) 
  {
   bayes[n] = fBayesianWgt[0][n] ;
   bayCheck += bayes[n] ;   
@@ -1835,13 +1835,13 @@ void AliFlowAnalyser::Weightening()
  cout << " AliFlowAnalyser::Weightening() " << endl ; cout << endl ;
  
  // PhiWgt histogram collection
- fPhiWgtHistList = new TOrdCollection(4*Flow::nSels*Flow::nHars) ;
+ fPhiWgtHistList = new TOrdCollection(4*AliFlowConstants::kSels*AliFlowConstants::kHars) ;
  
  // Creates PhiWgt Histograms
  TString* histTitle ;
- for(int k = 0; k < Flow::nSels; k++)
+ for(int k = 0; k < AliFlowConstants::kSels; k++)
  {
-  for(int j = 0; j < Flow::nHars; j++) 
+  for(int j = 0; j < AliFlowConstants::kHars; j++) 
   {
    // Tpc (plus)
    histTitle = new TString("Flow_Phi_Weight_TPCplus_Sel");
@@ -1994,13 +1994,13 @@ Bool_t AliFlowAnalyser::FillFromFlowEvent(AliFlowEvent* fFlowEvent)
  // gets event quantities, returns kFALSE if Q vector is always 0 
 
  Int_t selCheck = 0 ;
- for(Int_t k = 0; k < Flow::nSels; k++) 
+ for(Int_t k = 0; k < AliFlowConstants::kSels; k++) 
  {
   fFlowSelect->SetSelection(k) ;
-  for(Int_t j = 0; j < Flow::nHars; j++) 
+  for(Int_t j = 0; j < AliFlowConstants::kHars; j++) 
   {
    fFlowSelect->SetHarmonic(j) ;
-   for(Int_t n = 0; n < Flow::nSubs; n++) 
+   for(Int_t n = 0; n < AliFlowConstants::kSubs; n++) 
    {
     fFlowSelect->SetSubevent(n) ;
     fPsiSub[n][k][j] = fFlowEvent->Psi(fFlowSelect) ;          // sub-event quantities
@@ -2049,22 +2049,22 @@ void AliFlowAnalyser::FillEventHistograms(AliFlowEvent* fFlowEvent)
  for(int ii=0;ii<3;ii++) { fHistEnergyZDC->Fill(ii,fFlowEvent->ZDCenergy(ii)) ; }
 
  // sub-event Psi_Subs
- for(int k = 0; k < Flow::nSels; k++) 
+ for(int k = 0; k < AliFlowConstants::kSels; k++) 
  {
-  for(int j = 0; j < Flow::nHars; j++) 
+  for(int j = 0; j < AliFlowConstants::kHars; j++) 
   {
-   for(int n = 0; n < Flow::nSubs; n++) 
+   for(int n = 0; n < AliFlowConstants::kSubs; n++) 
    {
-    int iii = Flow::nSubs * k + n ;    //cout << "  " << k << j << n << " , " << iii << endl ;
+    int iii = AliFlowConstants::kSubs * k + n ;    //cout << "  " << k << j << n << " , " << iii << endl ;
     fHistSub[iii].fHistSubHar[j].fHistPsiSubs->Fill(fPsiSub[n][k][j]) ;
    }
   }
  }
 
  // full event Psi, PsiSubCorr, PsiSubCorrDiff, cos, mult, q
- for(int k = 0; k < Flow::nSels; k++) 
+ for(int k = 0; k < AliFlowConstants::kSels; k++) 
  {
-  for(int j = 0; j < Flow::nHars; j++) 
+  for(int j = 0; j < AliFlowConstants::kHars; j++) 
   {
    float order = (float)(j+1);
    fHistFull[k].fHistFullHar[j].fHistPsi->Fill(fPsi[k][j]);
@@ -2107,7 +2107,7 @@ void AliFlowAnalyser::FillEventHistograms(AliFlowEvent* fFlowEvent)
     fHistFull[k].fHistFullHar[j].fHistPsiSubCorr->Fill(psiSubCorr);
    }
 
-   if(j < Flow::nHars - 1) // subevents of different harmonics
+   if(j < AliFlowConstants::kHars - 1) // subevents of different harmonics
    {
     int j1 = 0 ; int j2 = 0 ;
     float psiSubCorrDiff;
@@ -2468,7 +2468,7 @@ void AliFlowAnalyser::FillParticleHistograms(TObjArray* fFlowTracks)
   }
 
   // cos(n*phiLab)
-  for(int j = 0; j < Flow::nHars; j++) 
+  for(int j = 0; j < AliFlowConstants::kHars; j++) 
   {
    bool oddHar = (j+1) % 2 ;
    float order = (float)(j+1) ;
@@ -2529,10 +2529,10 @@ void AliFlowAnalyser::FillParticleHistograms(TObjArray* fFlowTracks)
  fHistPidMult->Fill(15., muonPlusN);
 
  // Multiplicity of particles correlated with the event planes
- corrMultN /= (float)(Flow::nHars * Flow::nSels) ; 
+ corrMultN /= (float)(AliFlowConstants::kHars * AliFlowConstants::kSels) ; 
  fHistMultPart->Fill(corrMultN) ;
  // ...in one unit rapidity
- corrMultUnit /= (float)(Flow::nHars * Flow::nSels) ; 
+ corrMultUnit /= (float)(AliFlowConstants::kHars * AliFlowConstants::kSels) ; 
  fHistMultPartUnit->Fill(corrMultUnit) ;
 
  return ;
@@ -2551,29 +2551,29 @@ Int_t AliFlowAnalyser::HarmonicsLoop(AliFlowTrack* fFlowTrack)
 
  // Looping over Selections and Harmonics
  int corrMultN = 0 ;
- for (int k = 0; k < Flow::nSels; k++) 
+ for (int k = 0; k < AliFlowConstants::kSels; k++) 
  {
   fFlowSelect->SetSelection(k) ;
-  for (int j = 0; j < Flow::nHars; j++) 
+  for (int j = 0; j < AliFlowConstants::kHars; j++) 
   {
    bool oddHar = (j+1) % 2;
    fFlowSelect->SetHarmonic(j);
    double order  = (double)(j+1);
-   float psi_i = 0. ; float psi_2 = 0. ;
+   float psii = 0. ; float psi2 = 0. ;
    if(fFlowEvent->EtaSubs())          // particles with the opposite subevent
    {
-    if(eta > 0) { psi_i = fPsiSub[1][k][j] ; }     //check
-    else       { psi_i = fPsiSub[0][k][j] ; }
+    if(eta > 0) { psii = fPsiSub[1][k][j] ; }     //check
+    else       { psii = fPsiSub[0][k][j] ; }
    } 
    else if(order > 3. && !oddHar) 
    {
-    psi_i = fPsi[k][1];  // 2nd harmomic event plane
-    if(psi_i > 2*TMath::Pi()/order) { psi_i -= 2*TMath::Pi()/order ; } 
-    if(psi_i > 2*TMath::Pi()/order) { psi_i -= 2*TMath::Pi()/order ; }
+    psii = fPsi[k][1];  // 2nd harmomic event plane
+    if(psii > 2*TMath::Pi()/order) { psii -= 2*TMath::Pi()/order ; } 
+    if(psii > 2*TMath::Pi()/order) { psii -= 2*TMath::Pi()/order ; }
    } 
    else  // random subevents
    {
-    psi_i = fPsi[k][j] ;
+    psii = fPsi[k][j] ;
    }
 
    if(fFlowSelect->Select(fFlowTrack)) // Get detID
@@ -2623,22 +2623,22 @@ Int_t AliFlowAnalyser::HarmonicsLoop(AliFlowTrack* fFlowTrack)
     if(oddHar && eta<0.)  { phiWgt *= -1. ; } // restore value
 
     // Remove autocorrelations
-    TVector2 Q_i;
+    TVector2 qi;
     if(!fFlowEvent->EtaSubs())   // random subevents
     {
      if(order > 3. && !oddHar) // 2nd harmonic event plane
      { 
-      Q_i.Set(phiWgt * cos(phi * 2), phiWgt * sin(phi * 2));
-      TVector2 mQ_i = fQ[k][1] - Q_i;
-      psi_i = mQ_i.Phi() / 2;
-      if(psi_i < 0.) { psi_i += TMath::Pi() ; } 
+      qi.Set(phiWgt * cos(phi * 2), phiWgt * sin(phi * 2));
+      TVector2 mQi = fQ[k][1] - qi;
+      psii = mQi.Phi() / 2;
+      if(psii < 0.) { psii += TMath::Pi() ; } 
      } 
      else 
      {
-      Q_i.Set(phiWgt * cos(phi * order), phiWgt * sin(phi * order));
-      TVector2 mQ_i = fQ[k][j] - Q_i;
-      psi_i = mQ_i.Phi() / order;
-      if(psi_i < 0.) { psi_i += 2*TMath::Pi()/order ; }
+      qi.Set(phiWgt * cos(phi * order), phiWgt * sin(phi * order));
+      TVector2 mQi = fQ[k][j] - qi;
+      psii = mQi.Phi() / order;
+      if(psii < 0.) { psii += 2*TMath::Pi()/order ; }
      }
     }
           
@@ -2649,14 +2649,14 @@ Int_t AliFlowAnalyser::HarmonicsLoop(AliFlowTrack* fFlowTrack)
      usedForPsi2.SetHarmonic(1);
      if(usedForPsi2.Select(fFlowTrack))  // particle was used for Psi2
      {
-      Q_i.Set(phiWgt * cos(phi * 2), phiWgt * sin(phi * 2));
-      TVector2 mQ_i = fQ[k][1] - Q_i;
-      psi_2 = mQ_i.Phi() / 2;
-      if(psi_2 < 0.) { psi_2 += TMath::Pi() ; }
+      qi.Set(phiWgt * cos(phi * 2), phiWgt * sin(phi * 2));
+      TVector2 mQi = fQ[k][1] - qi;
+      psi2 = mQi.Phi() / 2;
+      if(psi2 < 0.) { psi2 += TMath::Pi() ; }
      }
      else                               // particle was not used for Psi2
      { 
-      psi_2 = fPsi[k][1];
+      psi2 = fPsi[k][1];
      }
     }
    }
@@ -2676,11 +2676,11 @@ Int_t AliFlowAnalyser::HarmonicsLoop(AliFlowTrack* fFlowTrack)
     float v;
     if (fV1Ep1Ep2 == kFALSE || order != 1) 
     {
-     v = 100 * cos(order * (phi - psi_i)) ;
+     v = 100 * cos(order * (phi - psii)) ;
     }
     else // i.e. (fV1Ep1Ep2 == kTRUE && order == 1)
     {
-     v = 100 * cos(phi + psi_i - 2*psi_2) ;
+     v = 100 * cos(phi + psii - 2*psi2) ;
     }
     
     float vFlip = v;
@@ -2744,13 +2744,13 @@ Int_t AliFlowAnalyser::HarmonicsLoop(AliFlowTrack* fFlowTrack)
     if(etaPtNoCut) { fHistFull[k].fHistvObs->Fill(order, vFlip) ; }
  
     // Correlation of Phi of selected particles with Psi
-    float phi_i = phi;
+    float phii = phi;
     if(eta < 0 && oddHar) 
     {
-     phi_i += TMath::Pi() ; // backward particle and odd harmonic
-     if(phi_i > 2*TMath::Pi()) { phi_i -= 2*TMath::Pi() ; }
+     phii += TMath::Pi() ; // backward particle and odd harmonic
+     if(phii > 2*TMath::Pi()) { phii -= 2*TMath::Pi() ; }
     }
-    float dPhi = phi_i - psi_i;
+    float dPhi = phii - psii;
     if(dPhi < 0.)             { dPhi += 2*TMath::Pi() ; }
     fHistFull[k].fHistFullHar[j].fHistPhiCorr->Fill(fmod((double)dPhi, 2*TMath::Pi() / order));
    }
@@ -2827,18 +2827,18 @@ void AliFlowAnalyser::FillV0Histograms(TObjArray* fFlowV0s)
     fHistV0sbBinPt->Fill(pt, pt);
    }
 
-   for(int k = 0; k < Flow::nSels; k++)  // sort of HarmonicsLoop - selection number used
+   for(int k = 0; k < AliFlowConstants::kSels; k++)  // sort of HarmonicsLoop - selection number used
    {
     fFlowSelect->SetSelection(k) ;
-    for(Int_t j=0;j<Flow::nHars;j++) 
+    for(Int_t j=0;j<AliFlowConstants::kHars;j++) 
     {
      Bool_t oddHar = (j+1) % 2 ;
      Float_t order = (Float_t)(j+1) ;
      fFlowSelect->SetHarmonic(j);      
 
      // Remove autocorrelations
-     Float_t psi_i, psi_2 ;
-     TVector2 Q_1, Q_2 ;
+     Float_t psii, psi2 ;
+     TVector2 q1, q2 ;
      Float_t phiDaughter1 = 0. ; Float_t phiDaughter2 = 0. ;
      Double_t phiWgt1 = 0. ; Double_t phiWgt2 = 0. ;
      // -
@@ -2863,30 +2863,30 @@ void AliFlowAnalyser::FillV0Histograms(TObjArray* fFlowV0s)
       } 
      }
 
-     // psi_2
-     Q_1.Set(phiWgt1 * cos(phiDaughter1 * 2), phiWgt1 * sin(phiDaughter1 * 2));
-     Q_2.Set(phiWgt2 * cos(phiDaughter2 * 2), phiWgt2 * sin(phiDaughter2 * 2));
-     TVector2 mQ_i = fQ[k][1] ; mQ_i -= Q_1 ; mQ_i -= Q_2 ; 
-     psi_2 = mQ_i.Phi() / 2 ;    
-     if(psi_2 < 0.)         { psi_2 += TMath::Pi() ; }
-     if(psi_2 > TMath::Pi()) { psi_2 -= TMath::Pi() ; } 
+     // psi2
+     q1.Set(phiWgt1 * cos(phiDaughter1 * 2), phiWgt1 * sin(phiDaughter1 * 2));
+     q2.Set(phiWgt2 * cos(phiDaughter2 * 2), phiWgt2 * sin(phiDaughter2 * 2));
+     TVector2 mQi = fQ[k][1] ; mQi -= q1 ; mQi -= q2 ; 
+     psi2 = mQi.Phi() / 2 ;      
+     if(psi2 < 0.)          { psi2 += TMath::Pi() ; }
+     if(psi2 > TMath::Pi())  { psi2 -= TMath::Pi() ; } 
 
-     // psi_i
-     if(order > 3. && !oddHar) { psi_i = psi_2 ; } 
+     // psii
+     if(order > 3. && !oddHar) { psii = psi2 ; } 
      else 
      {
-      Q_1.Set(phiWgt1 * cos(phiDaughter1 * order), phiWgt1 * sin(phiDaughter1 * order));
-      Q_2.Set(phiWgt2 * cos(phiDaughter2 * order), phiWgt2 * sin(phiDaughter2 * order));
-      TVector2 mQ_i = fQ[k][j] ; mQ_i -= Q_1 ; mQ_i -= Q_2 ;
-      psi_i = mQ_i.Phi()/order ; 
-      if(psi_i < 0.)                 { psi_i += 2*TMath::Pi()/order ; }        
-      if(psi_i > 2*TMath::Pi()/order) { psi_i -= 2*TMath::Pi()/order ; } 
+      q1.Set(phiWgt1 * cos(phiDaughter1 * order), phiWgt1 * sin(phiDaughter1 * order));
+      q2.Set(phiWgt2 * cos(phiDaughter2 * order), phiWgt2 * sin(phiDaughter2 * order));
+      TVector2 mQi = fQ[k][j] ; mQi -= q1 ; mQi -= q2 ;
+      psii = mQi.Phi()/order ; 
+      if(psii < 0.)                 { psii += 2*TMath::Pi()/order ; }  
+      if(psii > 2*TMath::Pi()/order) { psii -= 2*TMath::Pi()/order ; } 
      }
 
     // Caculate v for all V0s selected for correlation analysis
      float v ;
-     if(fV1Ep1Ep2 == kFALSE || order != 1) { v = 100 * cos(order * (phi - psi_i)) ; }
-     else { v = 100 * cos(phi + psi_i - 2*psi_2) ; }
+     if(fV1Ep1Ep2 == kFALSE || order != 1) { v = 100 * cos(order * (phi - psii)) ; }
+     else { v = 100 * cos(phi + psii - 2*psi2) ; }
      float vFlip = v ; if(eta < 0 && oddHar) { vFlip *= -1 ; }
 
      // invariant mass windows & sidebands
@@ -2960,13 +2960,13 @@ void AliFlowAnalyser::FillV0Histograms(TObjArray* fFlowV0s)
      }
    
      // Correlation of Phi of selected v0s with Psi
-     float phi_i = phi;
+     float phii = phi;
      if(eta < 0 && oddHar)
      {
-      phi_i += TMath::Pi() ; // backward particle and odd harmonic
-      if(phi_i > 2*TMath::Pi()) { phi_i -= 2*TMath::Pi() ; }
+      phii += TMath::Pi() ; // backward particle and odd harmonic
+      if(phii > 2*TMath::Pi()) { phii -= 2*TMath::Pi() ; }
      }
-     float dPhi = phi_i - psi_i;
+     float dPhi = phii - psii;
      if(dPhi < 0.)  { dPhi += 2*TMath::Pi() ; }
 
      if(inWin) { fHistFull[k].fHistFullHar[j].fHistV0PhiCorr->Fill(fmod((double)dPhi, 2*TMath::Pi() / order)) ; } 
@@ -2990,19 +2990,20 @@ void AliFlowAnalyser::FillV0Histograms(TObjArray* fFlowV0s)
 //  
 //  cout << " Fill Labels . " << endl ;  
 // 
+//  fLabHist ;
 //  return ;
 // }
 //-----------------------------------------------------------------------
-void AliFlowAnalyser::PrintEventQuantities()
+void AliFlowAnalyser::PrintEventQuantities() const
 {
  // prints event by event calculated quantities
 
  cout << endl ; cout << " # " << fEventNumber << " - Event quantities : " << endl ; cout << endl ; 
  
  cout << "fQ[k][j] = " ; 
- for(int k=0;k<Flow::nSels;k++) 
+ for(int k=0;k<AliFlowConstants::kSels;k++) 
  {
-  for(int j=0;j<Flow::nHars;j++) 
+  for(int j=0;j<AliFlowConstants::kHars;j++) 
   { 
    cout << (Float_t)fQ[k][j].X() << "," << (Float_t)fQ[k][j].Y() << " ; " ; 
   }
@@ -3010,50 +3011,50 @@ void AliFlowAnalyser::PrintEventQuantities()
   cout << "           " ; 
  }
  cout << endl ; cout << "fPsi[k][j] = " ; 
- for(int k=0;k<Flow::nSels;k++) 
+ for(int k=0;k<AliFlowConstants::kSels;k++) 
  {
-  for(int j=0;j<Flow::nHars;j++) { Float_t aaa = (Float_t)fPsi[k][j] ; cout << aaa << " , " ; }
+  for(int j=0;j<AliFlowConstants::kHars;j++) { Float_t aaa = (Float_t)fPsi[k][j] ; cout << aaa << " , " ; }
   cout << endl ;
   cout << "             " ; 
  }
  cout << endl ; cout << "fQnorm[k][j] = " ; 
- for(int k=0;k<Flow::nSels;k++) 
+ for(int k=0;k<AliFlowConstants::kSels;k++) 
  {
-  for(int j=0;j<Flow::nHars;j++) { Float_t aaa = (Float_t)fQnorm[k][j] ; cout << aaa << " , " ; }
+  for(int j=0;j<AliFlowConstants::kHars;j++) { Float_t aaa = (Float_t)fQnorm[k][j] ; cout << aaa << " , " ; }
   cout << endl ;
   cout << "            " ; 
  }
  cout << endl ; cout << "fMult[k][j] = " ; 
- for(int k=0;k<Flow::nSels;k++) 
+ for(int k=0;k<AliFlowConstants::kSels;k++) 
  {
-  for(int j=0;j<Flow::nHars;j++) { Float_t aaa = (Float_t)fMult[k][j] ; cout << aaa << " , " ; } 
+  for(int j=0;j<AliFlowConstants::kHars;j++) { Float_t aaa = (Float_t)fMult[k][j] ; cout << aaa << " , " ; } 
   cout << endl ;
   cout << "              " ; 
  }
  cout << endl ; cout << "fMultSub[n][k][j] = " ; 
- for(int n=0;n<Flow::nSubs;n++) 
+ for(int n=0;n<AliFlowConstants::kSubs;n++) 
  {
-  for(int k=0;k<Flow::nSels;k++) 
+  for(int k=0;k<AliFlowConstants::kSels;k++) 
   {
-   for(int j=0;j<Flow::nHars;j++) { Float_t aaa = fMultSub[n][k][j] ; cout << aaa << " , " ; } 
+   for(int j=0;j<AliFlowConstants::kHars;j++) { Float_t aaa = fMultSub[n][k][j] ; cout << aaa << " , " ; } 
    cout << endl ;
    cout << "                " ; 
   }
  }
  cout << endl ; cout << "fPsiSub[n][k][j] = " ; 
- for(int n=0;n<Flow::nSubs;n++) 
+ for(int n=0;n<AliFlowConstants::kSubs;n++) 
  {
-  for(int k=0;k<Flow::nSels;k++) 
+  for(int k=0;k<AliFlowConstants::kSels;k++) 
   {
-   for(int j=0;j<Flow::nHars;j++) { Float_t aaa = fPsiSub[n][k][j] ; cout << aaa << " , " ; } 
+   for(int j=0;j<AliFlowConstants::kHars;j++) { Float_t aaa = fPsiSub[n][k][j] ; cout << aaa << " , " ; } 
    cout << endl ;
    cout << "                " ; 
   }
  }
  cout << endl ; cout << "Delta_PsiSub[k][j] = " ; 
- for(int k=0;k<Flow::nSels;k++) 
+ for(int k=0;k<AliFlowConstants::kSels;k++) 
  {
-  for(int j=0;j<Flow::nHars;j++) { Float_t aaa = fPsiSub[0][k][j]-fPsiSub[1][k][j] ; cout << aaa << " , " ; } 
+  for(int j=0;j<AliFlowConstants::kHars;j++) { Float_t aaa = fPsiSub[0][k][j]-fPsiSub[1][k][j] ; cout << aaa << " , " ; } 
   cout << endl ;
   cout << "            " ; 
  }
@@ -3071,17 +3072,17 @@ Bool_t AliFlowAnalyser::Resolution()
  cout << " AliFlowAnalyser::Resolution()" << endl ;
  
  // VnRes histogram collection
- fVnResHistList = new TOrdCollection(Flow::nSels*Flow::nHars);
+ fVnResHistList = new TOrdCollection(AliFlowConstants::kSels*AliFlowConstants::kHars);
  
  // Calculate resolution from sqrt(fHistCos)
- double cosPair[Flow::nSels][Flow::nHars];
- double cosPairErr[Flow::nSels][Flow::nHars];
+ double cosPair[AliFlowConstants::kSels][AliFlowConstants::kHars];
+ double cosPairErr[AliFlowConstants::kSels][AliFlowConstants::kHars];
  double content, contentV0;
  double error, errorV0;
  double totalError;
  TString* histTitle;
 
- for(int k = 0; k < Flow::nSels; k++)
+ for(int k = 0; k < AliFlowConstants::kSels; k++)
  {
   // v for tracks (corrected for resolution)
   histTitle = new TString("Flow_v_Sel");
@@ -3103,7 +3104,7 @@ Bool_t AliFlowAnalyser::Resolution()
   delete histTitle;
   fVnResHistList->AddLast(fHistFull[k].fHistV0v);
    
-  for(int j = 0; j < Flow::nHars; j++) 
+  for(int j = 0; j < AliFlowConstants::kHars; j++) 
   {
    double order = (double)(j+1);
    cosPair[k][j]    = fHistFull[k].fHistCos->GetBinContent(j+1);
index 4100fecbc1939b1d1b141ff390dcc5b9f2675357..d0da0e8c41684bc2e7799fdcceaf3bdb6bb0ba80 100644 (file)
@@ -6,7 +6,8 @@
 //
 //////////////////////////////////////////////////////////////////////
 //
-// Description: flow analysis for AliFlowEvent(s), adapted from STAR .
+// Description: ALICE flow analysis for AliFlowEvent(s), 
+// adapted from the STAR flow analysis .
 // Original Authors:                 Raimond Snellings & Art Poskanzer
 //
 //////////////////////////////////////////////////////////////////////
@@ -14,7 +15,7 @@
 #ifndef ALIFLOWANALYSER_H
 #define ALIFLOWANALYSER_H
 
-#include <TVector2.h>
+// #include <TVector2.h>
 #include <TFile.h>
 #include "AliFlowConstants.h"
 
@@ -26,12 +27,13 @@ class TH3F;
 class TProfile;
 class TProfile2D;
 class TOrdCollection;
+class TVector2 ;
 
 class AliFlowTrack;
 class AliFlowV0;
 class AliFlowEvent;
 class AliFlowSelection;
-class Flow;
+class AliFlowConstants;
 
 class AliFlowAnalyser {
 
@@ -82,9 +84,9 @@ public:
   void     FillWgtArrays(TFile* wgtFile) ;                     // Loads phi & bayesian weights from file (flowPhiWgt.hist.root) and fills the arrays
 
  // Results
-  Float_t  GetRunBayesian(Int_t nPid=2, Int_t selN=0) ;        // Normalized Particle abundance (all events up to here)
-  void     PrintRunBayesian(Int_t selN=0) ;                    // Prints the normalized Particle abundance (up to here)
-  void     PrintEventQuantities() ;                            // Prints event by event calculated quantities
+  Float_t  GetRunBayesian(Int_t nPid=2, Int_t selN=0) const ;          // Normalized Particle abundance (all events up to here)
+  void     PrintRunBayesian(Int_t selN=0) const ;              // Prints the normalized Particle abundance (up to here)
+  void     PrintEventQuantities() const ;                      // Prints event by event calculated quantities
   Float_t  Res(Int_t eventN, Int_t harN) const                         { return fRes[eventN][harN]; }    // Returns the calculated resolution for the RP
   Float_t  ResErr(Int_t eventN, Int_t harN) const              { return fResErr[eventN][harN]; } // Returns the estimated error on the resolution 
 
@@ -113,6 +115,9 @@ public:
 
  private:
 
+  //AliFlowAnalyser(const AliFlowAnalyser &flowAnal)           { flowAnal.fPhiBins ; } // Copy Constructor (dummy)
+  //AliFlowAnalyser &operator=(const AliFlowAnalyser &flowAnal) { return *this ; }     // Assignment Operator
+
  // Flags
   Bool_t          fTrackLoop ;                                 //! tracks main loop
   Bool_t          fV0loop ;                                    //! correlation analysis is done also for neutral secundary vertex
@@ -157,24 +162,24 @@ public:
   Float_t          fPhiMin ;                                   //! wgt histo range (phi)
   Float_t          fPhiMax ;                                   //! wgt histo range (phi) 
 
-  Flow::PhiWgt_t    fPhiWgt ;                                  //! PhiWgt Array (all TPC)
-  Flow::PhiWgt_t    fPhiWgtPlus ;                              //! PhiWgt Array (TPC+)
-  Flow::PhiWgt_t    fPhiWgtMinus ;                             //! PhiWgt Array (TPC-)
-  Flow::PhiWgt_t    fPhiWgtCross ;                             //! PhiWgt Array (TPC/)     
+  AliFlowConstants::PhiWgt_t    fPhiWgt ;                      //! PhiWgt Array (all TPC)
+  AliFlowConstants::PhiWgt_t    fPhiWgtPlus ;                          //! PhiWgt Array (TPC+)
+  AliFlowConstants::PhiWgt_t    fPhiWgtMinus ;                 //! PhiWgt Array (TPC-)
+  AliFlowConstants::PhiWgt_t    fPhiWgtCross ;                 //! PhiWgt Array (TPC/)     
 
  // For bayesian weights
-  Double_t         fBayesianWgt[Flow::nSels][Flow::nPid] ;     //! Bayesian weights (expected particle abundance)
+  Double_t fBayesianWgt[AliFlowConstants::kSels][AliFlowConstants::kPid] ;     //! Bayesian weights (expected particle abundance)
 
 #ifndef __CINT__
-  TVector2 fQ[Flow::nSels][Flow::nHars];                       //! flow vector
-  Float_t  fPsi[Flow::nSels][Flow::nHars];                     //! event plane angle
-  UInt_t   fMult[Flow::nSels][Flow::nHars];                    //! multiplicity
-  Float_t  fQnorm[Flow::nSels][Flow::nHars];                    //! Q/Sqrt(Mult)
-  TVector2 fQSub[Flow::nSubs][Flow::nSels][Flow::nHars];       //! flow vector subs
-  Float_t  fPsiSub[Flow::nSubs][Flow::nSels][Flow::nHars];     //! plane angle of subevents
-  UInt_t   fMultSub[Flow::nSubs][Flow::nSels][Flow::nHars];    //! multiplicity subs
-  Float_t  fRes[Flow::nSels][Flow::nHars];                     //! event plane resolution
-  Float_t  fResErr[Flow::nSels][Flow::nHars];                  //! event plane resolution error
+  TVector2 fQ[AliFlowConstants::kSels][AliFlowConstants::kHars];                       //! flow vector
+  Float_t  fPsi[AliFlowConstants::kSels][AliFlowConstants::kHars];                     //! event plane angle
+  UInt_t   fMult[AliFlowConstants::kSels][AliFlowConstants::kHars];                    //! multiplicity
+  Float_t  fQnorm[AliFlowConstants::kSels][AliFlowConstants::kHars];                    //! Q/Sqrt(Mult)
+  TVector2 fQSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars];           //! flow vector subs
+  Float_t  fPsiSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars];         //! plane angle of subevents
+  UInt_t   fMultSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars];        //! multiplicity subs
+  Float_t  fRes[AliFlowConstants::kSels][AliFlowConstants::kHars];                     //! event plane resolution
+  Float_t  fResErr[AliFlowConstants::kSels][AliFlowConstants::kHars];                  //! event plane resolution error
 #endif /*__CINT__*/
 
  // for Histograms
@@ -199,317 +204,314 @@ public:
  // *****************
  // EVENTs HISTOGRAMS
  // *****************
-  TH1F*     fHistTrigger;                                 //!
-  TH1F*     fHistMult;                                    //!
-  TH1F*     fHistV0Mult;                                  //!
-  TH1F*     fHistOrigMult;                                //!
-  TH1F*     fHistMultOverOrig;                            //!
-  TH1F*     fHistMultEta;                                 //!
-  TH1F*     fHistCent;                                    //!
-  TH1F*     fHistVertexZ;                                 //!
-  TH2F*     fHistVertexXY2D;                              //!
-  TH2F*     fHistEnergyZDC;                               //!
-  TH1F*     fHistPartZDC;                                         //!
-  TProfile* fHistPidMult;                                 //!
-  TH1F*     fHistBayPidMult;                              //!
-  TH1F*     fHistEtaSym;                                  //!          // ...part also
-  TH1F*     fHistEtaSymPart;                              //!
-  TH2F*     fHistEtaSymVerZ2D;                            //!          // ...part also
-  TH2F*     fHistEtaSymVerZ2DPart;                        //!
+  TH1F*     fHistTrigger;                                 //! histogram ...
+  TH1F*     fHistMult;                                    //! histogram ...
+  TH1F*     fHistV0Mult;                                  //! histogram ...
+  TH1F*     fHistOrigMult;                                //! histogram ...
+  TH1F*     fHistMultOverOrig;                            //! histogram ...
+  TH1F*     fHistMultEta;                                 //! histogram ...
+  TH1F*     fHistCent;                                    //! histogram ...
+  TH1F*     fHistVertexZ;                                 //! histogram ...
+  TH2F*     fHistVertexXY2D;                              //! histogram ...
+  TH2F*     fHistEnergyZDC;                               //! histogram ...
+  TH1F*     fHistPartZDC;                                         //! histogram ...
+  TProfile* fHistPidMult;                                 //! histogram ...
+  TH1F*     fHistBayPidMult;                              //! histogram ...
+  TH1F*     fHistEtaSym;                                  //! histogram ...
+  TH1F*     fHistEtaSymPart;                              //! histogram ...
+  TH2F*     fHistEtaSymVerZ2D;                            //! histogram ...
+  TH2F*     fHistEtaSymVerZ2DPart;                        //! histogram ...
  // selected (TR & V0)
-  TH1F*     fHistMultPart;                                //!
-  TH1F*     fHistV0MultPart;                              //!
-  TH1F*     fHistBayPidMultPart;                          //!
-  TH1F*     fHistMultPartUnit;                                    //!
+  TH1F*     fHistMultPart;                                //! histogram ...
+  TH1F*     fHistV0MultPart;                              //! histogram ...
+  TH1F*     fHistBayPidMultPart;                          //! histogram ...
+  TH1F*     fHistMultPartUnit;                                    //! histogram ...
   
  // *****************
  // TRACKs HISTOGRAMS (all tracks)
  // *****************
-  TH1F*     fHistPtot ;                                   //!
-  TH1F*     fHistPt ;                                     //!
-  TH1F*     fHistCharge;                                  //!
-  TH1F*     fHistDcaGlobal;                               //!
-  TH1F*     fHistDca;                                     //!
-  TH1F*     fHistTransDca;                                        //!
-  TH1F*     fHistChi2;                                    //!
-  TH1F*     fHistLenght;                                  //!
-  TH1F*     fHistInvMass ;                                //!
-  TH1F*     fHistFitOverMax;                                      //!
-  TH2D*     fHistPhiPtCon ;                               //!
-  TH2D*     fHistPhiPtUnc ;                               //!
-  TH2D*     fHistPtPhiPos ;                               //!
-  TH2D*     fHistPtPhiNeg ;                               //!
-  TH3F*     fHistAllEtaPtPhi3D;                           //!
-  TProfile* fHistCosPhi;                                  //!
-  TH2F*     fHistPidPt;                                   //!
-  TH1F*     fHistPhi ;                                            //!
-  TH1F*     fHistPhiCons ;                                //!
-  TH2D*     fHistYieldAll2D;                              //!
-  TH2D*     fHistYieldCon2D;                              //!
-  TH2D*     fHistYieldUnc2D;                              //!
-  TH3F*     fHistConsEtaPtPhi3D;                          //!
-  TH3F*     fHistGlobEtaPtPhi3D;                          //! 
-  TH3F*     fHistUncEtaPtPhi3D ;                          //!
-  // fit & dE/dX for each detector (all tracks) 
-  TH1F*     fHistChi2ITS;                                 //!
-  TH1F*     fHistChi2normITS;                             //!
-  TH1F*     fHistFitPtsITS;                               //!
-  TH1F*     fHistMaxPtsITS;                               //!
-  TH2F*     fHistMeanDedxPos2DITS;                        //!
-  TH2F*     fHistMeanDedxNeg2DITS;                        //!
+  TH1F*     fHistPtot ;                                   //! histogram ...
+  TH1F*     fHistPt ;                                     //! histogram ...
+  TH1F*     fHistCharge;                                  //! histogram ...
+  TH1F*     fHistDcaGlobal;                               //! histogram ...
+  TH1F*     fHistDca;                                     //! histogram ...
+  TH1F*     fHistTransDca;                                        //! histogram ...
+  TH1F*     fHistChi2;                                    //! histogram ...
+  TH1F*     fHistLenght;                                  //! histogram ...
+  TH1F*     fHistInvMass ;                                //! histogram ...
+  TH1F*     fHistFitOverMax;                                      //! histogram ...
+  TH2D*     fHistPhiPtCon ;                               //! histogram ...
+  TH2D*     fHistPhiPtUnc ;                               //! histogram ...
+  TH2D*     fHistPtPhiPos ;                               //! histogram ...
+  TH2D*     fHistPtPhiNeg ;                               //! histogram ...
+  TH3F*     fHistAllEtaPtPhi3D;                           //! histogram ...
+  TProfile* fHistCosPhi;                                  //! histogram ...
+  TH2F*     fHistPidPt;                                   //! histogram ...
+  TH1F*     fHistPhi ;                                            //! histogram ...
+  TH1F*     fHistPhiCons ;                                //! histogram ...
+  TH2D*     fHistYieldAll2D;                              //! histogram ...
+  TH2D*     fHistYieldCon2D;                              //! histogram ...
+  TH2D*     fHistYieldUnc2D;                              //! histogram ...
+  TH3F*     fHistConsEtaPtPhi3D;                          //! histogram ...
+  TH3F*     fHistGlobEtaPtPhi3D;                          //! histogram ...
+  TH3F*     fHistUncEtaPtPhi3D ;                          //! histogram ...
+  // fit & dE/dX for each detector (all tracks)
+  TH1F*     fHistChi2ITS;                                 //! histogram ...
+  TH1F*     fHistChi2normITS;                             //! histogram ...
+  TH1F*     fHistFitPtsITS;                               //! histogram ...
+  TH1F*     fHistMaxPtsITS;                               //! histogram ...
+  TH2F*     fHistMeanDedxPos2DITS;                        //! histogram ...
+  TH2F*     fHistMeanDedxNeg2DITS;                        //! histogram ...
   // -
-  TH1F*     fHistChi2TPC;                                 //!
-  TH1F*     fHistChi2normTPC;                             //!
-  TH1F*     fHistFitPtsTPC;                               //!
-  TH1F*     fHistMaxPtsTPC;                               //!
-  TH1F*     fHistFitOverMaxTPC;                           //!
-  TH2F*     fHistMeanDedxPos2D;                           //!
-  TH2F*     fHistMeanDedxNeg2D;                           //!
+  TH1F*     fHistChi2TPC;                                 //! histogram ...
+  TH1F*     fHistChi2normTPC;                             //! histogram ...
+  TH1F*     fHistFitPtsTPC;                               //! histogram ...
+  TH1F*     fHistMaxPtsTPC;                               //! histogram ...
+  TH1F*     fHistFitOverMaxTPC;                           //! histogram ...
+  TH2F*     fHistMeanDedxPos2D;                           //! histogram ...
+  TH2F*     fHistMeanDedxNeg2D;                           //! histogram ...
   // -
-  TH1F*     fHistChi2TRD;                                 //!
-  TH1F*     fHistChi2normTRD;                             //!
-  TH1F*     fHistFitPtsTRD;                               //!
-  TH1F*     fHistMaxPtsTRD;                               //!
-  TH2F*     fHistMeanDedxPos2DTRD;                        //!
-  TH2F*     fHistMeanDedxNeg2DTRD;                        //!
+  TH1F*     fHistChi2TRD;                                 //! histogram ...
+  TH1F*     fHistChi2normTRD;                             //! histogram ...
+  TH1F*     fHistFitPtsTRD;                               //! histogram ...
+  TH1F*     fHistMaxPtsTRD;                               //! histogram ...
+  TH2F*     fHistMeanDedxPos2DTRD;                        //! histogram ...
+  TH2F*     fHistMeanDedxNeg2DTRD;                        //! histogram ...
   // -
-  TH1F*     fHistChi2TOF;                                 //!
-  TH1F*     fHistChi2normTOF;                             //!
-  TH1F*     fHistFitPtsTOF;                               //!
-  TH1F*     fHistMaxPtsTOF;                               //!
-  TH2F*     fHistMeanDedxPos2DTOF;                        //!
-  TH2F*     fHistMeanDedxNeg2DTOF;                        //!
+  TH1F*     fHistChi2TOF;                                 //! histogram ...
+  TH1F*     fHistChi2normTOF;                             //! histogram ...
+  TH1F*     fHistFitPtsTOF;                               //! histogram ...
+  TH1F*     fHistMaxPtsTOF;                               //! histogram ...
+  TH2F*     fHistMeanDedxPos2DTOF;                        //! histogram ...
+  TH2F*     fHistMeanDedxNeg2DTOF;                        //! histogram ...
   // detector response for particle type (all tracks, based on Pid)
-  TH2F*     fHistMeanTPCPiPlus ;                          //!
-  TH2F*     fHistMeanTPCPiMinus ;                         //!
-  TH2F*     fHistMeanTPCProton ;                          //!
-  TH2F*     fHistMeanTPCPbar ;                            //!
-  TH2F*     fHistMeanTPCKplus ;                           //!
-  TH2F*     fHistMeanTPCKminus ;                          //!
-  TH2F*     fHistMeanTPCDeuteron ;                        //!
-  TH2F*     fHistMeanTPCAntiDeuteron ;                    //!
-  TH2F*     fHistMeanTPCPositron ;                        //!
-  TH2F*     fHistMeanTPCElectron ;                        //!
-  TH2F*     fHistMeanTPCMuonPlus ;                        //!
-  TH2F*     fHistMeanTPCMuonMinus ;                       //!
+  TH2F*     fHistMeanTPCPiPlus ;                          //! histogram ...
+  TH2F*     fHistMeanTPCPiMinus ;                         //! histogram ...
+  TH2F*     fHistMeanTPCProton ;                          //! histogram ...
+  TH2F*     fHistMeanTPCPbar ;                            //! histogram ...
+  TH2F*     fHistMeanTPCKplus ;                           //! histogram ...
+  TH2F*     fHistMeanTPCKminus ;                          //! histogram ...
+  TH2F*     fHistMeanTPCDeuteron ;                        //! histogram ...
+  TH2F*     fHistMeanTPCAntiDeuteron ;                    //! histogram ...
+  TH2F*     fHistMeanTPCPositron ;                        //! histogram ...
+  TH2F*     fHistMeanTPCElectron ;                        //! histogram ...
+  TH2F*     fHistMeanTPCMuonPlus ;                        //! histogram ...
+  TH2F*     fHistMeanTPCMuonMinus ;                       //! histogram ...
   // -
-  TH2F*     fHistMeanITSPiPlus ;                          //!
-  TH2F*     fHistMeanITSPiMinus ;                         //!
-  TH2F*     fHistMeanITSProton ;                          //!
-  TH2F*     fHistMeanITSPbar ;                            //!
-  TH2F*     fHistMeanITSKplus ;                           //!
-  TH2F*     fHistMeanITSKminus ;                          //!
-  TH2F*     fHistMeanITSDeuteron ;                        //!
-  TH2F*     fHistMeanITSAntiDeuteron ;                    //!
-  TH2F*     fHistMeanITSPositron ;                        //!
-  TH2F*     fHistMeanITSElectron ;                        //!
-  TH2F*     fHistMeanITSMuonPlus ;                        //!
-  TH2F*     fHistMeanITSMuonMinus ;                       //!
+  TH2F*     fHistMeanITSPiPlus ;                          //! histogram ...
+  TH2F*     fHistMeanITSPiMinus ;                         //! histogram ...
+  TH2F*     fHistMeanITSProton ;                          //! histogram ...
+  TH2F*     fHistMeanITSPbar ;                            //! histogram ...
+  TH2F*     fHistMeanITSKplus ;                           //! histogram ...
+  TH2F*     fHistMeanITSKminus ;                          //! histogram ...
+  TH2F*     fHistMeanITSDeuteron ;                        //! histogram ...
+  TH2F*     fHistMeanITSAntiDeuteron ;                    //! histogram ...
+  TH2F*     fHistMeanITSPositron ;                        //! histogram ...
+  TH2F*     fHistMeanITSElectron ;                        //! histogram ...
+  TH2F*     fHistMeanITSMuonPlus ;                        //! histogram ...
+  TH2F*     fHistMeanITSMuonMinus ;                       //! histogram ...
   // -
-  TH2F*     fHistMeanTOFPiPlus ;                          //!
-  TH2F*     fHistMeanTOFPiMinus ;                         //!
-  TH2F*     fHistMeanTOFProton ;                          //!
-  TH2F*     fHistMeanTOFPbar ;                            //!
-  TH2F*     fHistMeanTOFKplus ;                           //!
-  TH2F*     fHistMeanTOFKminus ;                          //!
-  TH2F*     fHistMeanTOFDeuteron ;                        //!
-  TH2F*     fHistMeanTOFAntiDeuteron ;                    //!
-  TH2F*     fHistMeanTOFPositron ;                        //!
-  TH2F*     fHistMeanTOFElectron ;                        //!
-  TH2F*     fHistMeanTOFMuonPlus ;                        //!
-  TH2F*     fHistMeanTOFMuonMinus ;                       //!
+  TH2F*     fHistMeanTOFPiPlus ;                          //! histogram ...
+  TH2F*     fHistMeanTOFPiMinus ;                         //! histogram ...
+  TH2F*     fHistMeanTOFProton ;                          //! histogram ...
+  TH2F*     fHistMeanTOFPbar ;                            //! histogram ...
+  TH2F*     fHistMeanTOFKplus ;                           //! histogram ...
+  TH2F*     fHistMeanTOFKminus ;                          //! histogram ...
+  TH2F*     fHistMeanTOFDeuteron ;                        //! histogram ...
+  TH2F*     fHistMeanTOFAntiDeuteron ;                    //! histogram ...
+  TH2F*     fHistMeanTOFPositron ;                        //! histogram ...
+  TH2F*     fHistMeanTOFElectron ;                        //! histogram ...
+  TH2F*     fHistMeanTOFMuonPlus ;                        //! histogram ...
+  TH2F*     fHistMeanTOFMuonMinus ;                       //! histogram ...
   // -
-  TH2F*     fHistMeanTRDPiPlus ;                          //!
-  TH2F*     fHistMeanTRDPiMinus ;                         //!
-  TH2F*     fHistMeanTRDProton ;                          //!
-  TH2F*     fHistMeanTRDPbar ;                            //!
-  TH2F*     fHistMeanTRDKplus ;                           //!
-  TH2F*     fHistMeanTRDKminus ;                          //!
-  TH2F*     fHistMeanTRDDeuteron ;                        //!
-  TH2F*     fHistMeanTRDAntiDeuteron ;                    //!
-  TH2F*     fHistMeanTRDPositron ;                        //!
-  TH2F*     fHistMeanTRDElectron ;                        //!
-  TH2F*     fHistMeanTRDMuonPlus ;                        //!
-  TH2F*     fHistMeanTRDMuonMinus ;                       //!
+  TH2F*     fHistMeanTRDPiPlus ;                          //! histogram ...
+  TH2F*     fHistMeanTRDPiMinus ;                         //! histogram ...
+  TH2F*     fHistMeanTRDProton ;                          //! histogram ...
+  TH2F*     fHistMeanTRDPbar ;                            //! histogram ...
+  TH2F*     fHistMeanTRDKplus ;                           //! histogram ...
+  TH2F*     fHistMeanTRDKminus ;                          //! histogram ...
+  TH2F*     fHistMeanTRDDeuteron ;                        //! histogram ...
+  TH2F*     fHistMeanTRDAntiDeuteron ;                    //! histogram ...
+  TH2F*     fHistMeanTRDPositron ;                        //! histogram ...
+  TH2F*     fHistMeanTRDElectron ;                        //! histogram ...
+  TH2F*     fHistMeanTRDMuonPlus ;                        //! histogram ...
+  TH2F*     fHistMeanTRDMuonMinus ;                       //! histogram ...
   // pid probability for all particle (all tracks)
-  TH1F*     fHistPidPiPlus;                               //!
-  TH1F*     fHistPidPiMinus;                              //!
-  TH1F*     fHistPidProton;                               //!
-  TH1F*     fHistPidAntiProton;                           //!
-  TH1F*     fHistPidKplus;                                //!
-  TH1F*     fHistPidKminus;                               //!
-  TH1F*     fHistPidDeuteron;                             //!
-  TH1F*     fHistPidAntiDeuteron;                         //!
-  TH1F*     fHistPidElectron;                             //!
-  TH1F*     fHistPidPositron;                             //!
-  TH1F*     fHistPidMuonMinus;                            //!
-  TH1F*     fHistPidMuonPlus;                             //!
+  TH1F*     fHistPidPiPlus;                               //! histogram ...
+  TH1F*     fHistPidPiMinus;                              //! histogram ...
+  TH1F*     fHistPidProton;                               //! histogram ...
+  TH1F*     fHistPidAntiProton;                           //! histogram ...
+  TH1F*     fHistPidKplus;                                //! histogram ...
+  TH1F*     fHistPidKminus;                               //! histogram ...
+  TH1F*     fHistPidDeuteron;                             //! histogram ...
+  TH1F*     fHistPidAntiDeuteron;                         //! histogram ...
+  TH1F*     fHistPidElectron;                             //! histogram ...
+  TH1F*     fHistPidPositron;                             //! histogram ...
+  TH1F*     fHistPidMuonMinus;                            //! histogram ...
+  TH1F*     fHistPidMuonPlus;                             //! histogram ...
   // pid probability for particle type (all tracks, based on Pid)
-  TH1F*     fHistPidPiPlusPart;                           //!
-  TH1F*     fHistPidPiMinusPart;                          //!
-  TH1F*     fHistPidProtonPart;                           //!
-  TH1F*     fHistPidAntiProtonPart;                       //!
-  TH1F*     fHistPidKplusPart;                            //!
-  TH1F*     fHistPidKminusPart;                           //!
-  TH1F*     fHistPidDeuteronPart;                         //!
-  TH1F*     fHistPidAntiDeuteronPart;                     //!
-  TH1F*     fHistPidElectronPart;                         //!
-  TH1F*     fHistPidPositronPart;                         //!
-  TH1F*     fHistPidMuonMinusPart;                        //!
-  TH1F*     fHistPidMuonPlusPart;                         //!
+  TH1F*     fHistPidPiPlusPart;                           //! histogram ...
+  TH1F*     fHistPidPiMinusPart;                          //! histogram ...
+  TH1F*     fHistPidProtonPart;                           //! histogram ...
+  TH1F*     fHistPidAntiProtonPart;                       //! histogram ...
+  TH1F*     fHistPidKplusPart;                            //! histogram ...
+  TH1F*     fHistPidKminusPart;                           //! histogram ...
+  TH1F*     fHistPidDeuteronPart;                         //! histogram ...
+  TH1F*     fHistPidAntiDeuteronPart;                     //! histogram ...
+  TH1F*     fHistPidElectronPart;                         //! histogram ...
+  TH1F*     fHistPidPositronPart;                         //! histogram ...
+  TH1F*     fHistPidMuonMinusPart;                        //! histogram ...
+  TH1F*     fHistPidMuonPlusPart;                         //! histogram ...
   // MC labels from the simulation (all tracks)
-  TH2F*     mLabHist;                                     //! 
+  //TH2F*     fLabHist;                                           //! histogram ... 
  // *****************
  // selected TRACKS
  // *****************
-  TProfile* fHistBinEta;                                  //!
-  TProfile* fHistBinPt;                                   //!
+  TProfile* fHistBinEta;                                  //! histogram ...
+  TProfile* fHistBinPt;                                   //! histogram ...
   //
-  TH3F*     fHistEtaPtPhi3DPart ;                         //!
-  TH2D*     fHistYieldPart2D;                             //!
-  TH1F*     fHistDcaGlobalPart ;                          //!
-  TH1F*     fHistInvMassPart ;                            //!
-  TH3F*     fHistEtaPtPhi3DOut ;                          //!
-  TH2D*     fHistYieldOut2D;                              //!
-  TH1F*     fHistDcaGlobalOut ;                                   //!
-  TH1F*     fHistInvMassOut ;                             //!
-  TH3F*     fHistMeanDedxPos3DPart ;                      //!
-  TH3F*     fHistMeanDedxNeg3DPart ;                      //!
-  TH3F*     fHistMeanDedxPos3DPartITS ;                           //!
-  TH3F*     fHistMeanDedxNeg3DPartITS ;                           //!
+  TH3F*     fHistEtaPtPhi3DPart ;                         //! histogram ...
+  TH2D*     fHistYieldPart2D;                             //! histogram ...
+  TH1F*     fHistDcaGlobalPart ;                          //! histogram ...
+  TH1F*     fHistInvMassPart ;                            //! histogram ...
+  TH3F*     fHistEtaPtPhi3DOut ;                          //! histogram ...
+  TH2D*     fHistYieldOut2D;                              //! histogram ...
+  TH1F*     fHistDcaGlobalOut ;                                   //! histogram ...
+  TH1F*     fHistInvMassOut ;                             //! histogram ...
+  TH3F*     fHistMeanDedxPos3DPart ;                      //! histogram ...
+  TH3F*     fHistMeanDedxNeg3DPart ;                      //! histogram ...
+  TH3F*     fHistMeanDedxPos3DPartITS ;                           //! histogram ...
+  TH3F*     fHistMeanDedxNeg3DPartITS ;                           //! histogram ...
 //
 
  // *****************
  // V0s HISTOGRAMS (all v0s)
  // *****************
-  TH1F*     fHistV0Mass;                                  //!
-  TH3F*     fHistV0EtaPtPhi3D;                            //!
-  TH2D*     fHistV0YieldAll2D;                            //!
-  TH2D*     fHistV0PYall2D;                                       //!
-  TH1F*     fHistV0Dca;                                           //!
-  TH1F*     fHistV0Chi2;                                  //!
-  TH1F*     fHistV0Lenght;                                //!
-  TH1F*     fHistV0Sigma;                                 //!
-  TProfile* fHistV0CosPhi;                                //! 
-  TH2D*     fHistV0MassPtSlices;                          //!
+  TH1F*     fHistV0Mass;                                  //! histogram ...
+  TH3F*     fHistV0EtaPtPhi3D;                            //! histogram ...
+  TH2D*     fHistV0YieldAll2D;                            //! histogram ...
+  TH2D*     fHistV0PYall2D;                                       //! histogram ...
+  TH1F*     fHistV0Dca;                                           //! histogram ...
+  TH1F*     fHistV0Chi2;                                  //! histogram ...
+  TH1F*     fHistV0Lenght;                                //! histogram ...
+  TH1F*     fHistV0Sigma;                                 //! histogram ...
+  TProfile* fHistV0CosPhi;                                //! histogram ... 
+  TH2D*     fHistV0MassPtSlices;                          //! histogram ...
  // *****************
  // selected V0s
  // *****************
-  TProfile* fHistV0BinEta;                                //! 
-  TProfile* fHistV0BinPt;                                 //! 
-  TProfile* fHistV0sbBinEta;                              //! 
-  TProfile* fHistV0sbBinPt;                               //!
+  TProfile* fHistV0BinEta;                                //! histogram ... 
+  TProfile* fHistV0BinPt;                                 //! histogram ... 
+  TProfile* fHistV0sbBinEta;                              //! histogram ... 
+  TProfile* fHistV0sbBinPt;                               //! histogram ...
   //
-  TH1F*     fHistV0MassWin ;                              //!
-  TH3F*     fHistV0EtaPtPhi3DPart ;                       //!
-  TH2D*     fHistV0YieldPart2D;                           //!
-  TH1F*     fHistV0DcaPart ;                              //!
-  TH1F*     fHistV0LenghtPart ;                                   //!
-  TH1F*     fHistV0sbMassSide ;                           //!
-  TH3F*     fHistV0sbEtaPtPhi3DPart ;                     //!
-  TH2D*     fHistV0sbYieldPart2D;                         //!
-  TH1F*     fHistV0sbDcaPart ;                            //!
-  TH1F*     fHistV0sbLenghtPart ;                         //!
+  TH1F*     fHistV0MassWin ;                              //! histogram ...
+  TH3F*     fHistV0EtaPtPhi3DPart ;                       //! histogram ...
+  TH2D*     fHistV0YieldPart2D;                           //! histogram ...
+  TH1F*     fHistV0DcaPart ;                              //! histogram ...
+  TH1F*     fHistV0LenghtPart ;                                   //! histogram ...
+  TH1F*     fHistV0sbMassSide ;                           //! histogram ...
+  TH3F*     fHistV0sbEtaPtPhi3DPart ;                     //! histogram ...
+  TH2D*     fHistV0sbYieldPart2D;                         //! histogram ...
+  TH1F*     fHistV0sbDcaPart ;                            //! histogram ...
+  TH1F*     fHistV0sbLenghtPart ;                         //! histogram ...
 
 // for each harmonic, each selection, and each sub-event
 
  // *****************
  // SUB-EVENTs HISTOGRAMS
  // *****************
-  struct histSubHars {
-   TH1F*     fHistPsiSubs;
+  struct AliHistSubHars {
+   TH1F*     fHistPsiSubs;                                //! histogram ...
   };
-  struct histSubs;     
-  friend struct histSubs;
-  struct histSubs {
-   struct histSubHars fHistSubHar[Flow::nHars];
+
+  struct AliHistSubs {
+   struct AliHistSubHars fHistSubHar[AliFlowConstants::kHars];         //! structure array ... 
   };
-  struct histSubs fHistSub[Flow::nSels*Flow::nSubs];        //!
+  struct AliHistSubs fHistSub[AliFlowConstants::kSels*AliFlowConstants::kSubs];    //! structure ...
 
 // for each harmonic and each selection
 
-  struct histFullHars 
+  struct AliHistFullHars 
   {
    // weights
-    TH1D*       fHistPhiPlus;
-    TH1D*       fHistPhiMinus;
-    TH1D*       fHistPhiAll;
-    TH1D*       fHistPhiWgtPlus;
-    TH1D*       fHistPhiWgtMinus;
-    TH1D*       fHistPhiWgtAll;
-    TH1D*       fHistPhiFlatPlus;
-    TH1D*       fHistPhiFlatMinus;
-    TH1D*       fHistPhiFlatAll;
-    TH1D*       fHistPhi;
-    TH1D*       fHistPhiWgt;
-    TH1D*       fHistPhiFlat;
+    TH1D*       fHistPhiPlus;                             //! histogram ...
+    TH1D*       fHistPhiMinus;                            //! histogram ...
+    TH1D*       fHistPhiAll;                              //! histogram ...
+    TH1D*       fHistPhiWgtPlus;                          //! histogram ...
+    TH1D*       fHistPhiWgtMinus;                         //! histogram ...
+    TH1D*       fHistPhiWgtAll;                           //! histogram ...
+    TH1D*       fHistPhiFlatPlus;                         //! histogram ...
+    TH1D*       fHistPhiFlatMinus;                        //! histogram ...
+    TH1D*       fHistPhiFlatAll;                          //! histogram ...
+    TH1D*       fHistPhi;                                 //! histogram ...
+    TH1D*       fHistPhiWgt;                              //! histogram ...
+    TH1D*       fHistPhiFlat;                             //! histogram ...
    // flow (events)
-    TH1F*       fHistPsi;
-    TH1F*       fHistPsiSubCorr;
-    TH1F*       fHistPsiSubCorrDiff;
-    TH1F*       fHistPsiDiff;
-    TH1F*       fHistMult;
-    TH1F*       fHistQnorm;
+    TH1F*       fHistPsi;                                 //! histogram ...
+    TH1F*       fHistPsiSubCorr;                          //! histogram ...
+    TH1F*       fHistPsiSubCorrDiff;                      //! histogram ...
+    TH1F*       fHistPsiDiff;                             //! histogram ...
+    TH1F*       fHistMult;                                //! histogram ...
+    TH1F*       fHistQnorm;                               //! histogram ...
    // flow (tracks)
-    TH1F*       fHistPhiCorr;
-    TProfile2D* fHistvObs2D;
-    TProfile*   fHistvObsEta;
-    TProfile*   fHistvObsPt;
-    TH2D*       fHistv2D;
-    TH1D*       fHistvEta;
-    TH1D*       fHistvPt;
-   // flow (v0s)
-    TH1F*       fHistV0PhiCorr;   
-    TProfile2D* fHistV0vObs2D;   
-    TProfile*   fHistV0vObsEta;  
-    TProfile*   fHistV0vObsPt;   
-    TH2D*      fHistV0v2D;      
-    TH1D*      fHistV0vEta;     
-    TH1D*      fHistV0vPt;      
+    TH1F*       fHistPhiCorr;                             //! histogram ...
+    TProfile2D* fHistvObs2D;                              //! histogram ...
+    TProfile*   fHistvObsEta;                             //! histogram ...
+    TProfile*   fHistvObsPt;                              //! histogram ...
+    TH2D*       fHistv2D;                                 //! histogram ...
+    TH1D*       fHistvEta;                                //! histogram ...
+    TH1D*       fHistvPt;                                 //! histogram ...
+   // flow (v0s)                                          
+    TH1F*       fHistV0PhiCorr;                           //! histogram ...
+    TProfile2D* fHistV0vObs2D;                            //! histogram ...
+    TProfile*   fHistV0vObsEta;                           //! histogram ...
+    TProfile*   fHistV0vObsPt;                            //! histogram ...
+    TH2D*      fHistV0v2D;                                //! histogram ...
+    TH1D*      fHistV0vEta;                               //! histogram ...     
+    TH1D*      fHistV0vPt;                                //! histogram ...     
    // flow (v0s sidebands)
-    TProfile*   fHistV0sbvObsEtaSx ;  
-    TProfile*   fHistV0sbvObsPtSx ;   
-    TProfile*   fHistV0sbvObsEtaDx ;  
-    TProfile*   fHistV0sbvObsPtDx ;   
-    TH1F*       fHistV0sbPhiCorr ;   
-    TProfile2D* fHistV0sbvObs2D ;   
-    TProfile*   fHistV0sbvObsEta ;  
-    TProfile*   fHistV0sbvObsPt ;   
-    TH2D*      fHistV0sbv2D ;      
-    TH1D*      fHistV0sbvEta ;     
-    TH1D*      fHistV0sbvPt ;      
+    TProfile*   fHistV0sbvObsEtaSx ;                      //! histogram ...  
+    TProfile*   fHistV0sbvObsPtSx ;                       //! histogram ...
+    TProfile*   fHistV0sbvObsEtaDx ;                      //! histogram ...
+    TProfile*   fHistV0sbvObsPtDx ;                       //! histogram ...
+    TH1F*       fHistV0sbPhiCorr ;                        //! histogram ...
+    TProfile2D* fHistV0sbvObs2D ;                         //! histogram ...
+    TProfile*   fHistV0sbvObsEta ;                        //! histogram ...
+    TProfile*   fHistV0sbvObsPt ;                         //! histogram ...
+    TH2D*      fHistV0sbv2D ;                             //! histogram ...
+    TH1D*      fHistV0sbvEta ;                            //! histogram ...
+    TH1D*      fHistV0sbvPt ;                             //! histogram ...
    // check (tracks used for R.P.)
-    TH1F*       fHistYieldPt ;
-    TH3F*       fHistEtaPtPhi3D ;
-    TH2D*       fHistYield2D ;
-    TH1F*       fHistDcaGlob ;
+    TH1F*       fHistYieldPt ;                            //! histogram ...
+    TH3F*       fHistEtaPtPhi3D ;                         //! histogram ...
+    TH2D*       fHistYield2D ;                            //! histogram ...
+    TH1F*       fHistDcaGlob ;                            //! histogram ...
    // check (tracks excluded)
-    TH1F*      fHistYieldPtout;
-    TH3F*      fHistEtaPtPhi3Dout ;
-    TH2D*      fHistYield2Dout ;
-    TH1F*      fHistDcaGlobout ;
+    TH1F*      fHistYieldPtout;                           //! histogram ...
+    TH3F*      fHistEtaPtPhi3Dout ;                       //! histogram ...
+    TH2D*      fHistYield2Dout ;                          //! histogram ...
+    TH1F*      fHistDcaGlobout ;                          //! histogram ...
   };
 
 // for each selection
 
-  struct histFulls;    
-  friend struct histFulls;
-  struct histFulls 
+  struct AliHistFulls 
   {
-   TH1F*     fHistBayPidMult;
+   TH1F*     fHistBayPidMult;                            //! histogram ...
   // flow (events)
-   TProfile* fHistCos;
-   TH1F*     fHistRes;
-   TProfile* fHistvObs;
-   TH1D*     fHistv;
-   TProfile* fHistV0vObs;
-   TProfile* fHistV0sbvObsSx;
-   TProfile* fHistV0sbvObsDx;
-   TH1D*     fHistV0v;
+   TProfile* fHistCos;                                   //! histogram ...
+   TH1F*     fHistRes;                                   //! histogram ...
+   TProfile* fHistvObs;                                  //! histogram ...
+   TH1D*     fHistv;                                     //! histogram ...
+   TProfile* fHistV0vObs;                                //! histogram ...
+   TProfile* fHistV0sbvObsSx;                            //! histogram ...
+   TProfile* fHistV0sbvObsDx;                            //! histogram ...
+   TH1D*     fHistV0v;                                   //! histogram ...
   // wgt, evts, trks, v0s (as defined above)
-   struct histFullHars  fHistFullHar[Flow::nHars];
+   struct AliHistFullHars  fHistFullHar[AliFlowConstants::kHars];        //! structure array ...
   };
-  struct histFulls fHistFull[Flow::nSels];                     //!
+  struct AliHistFulls fHistFull[AliFlowConstants::kSels];             //! structure array ...
 
   ClassDef(AliFlowAnalyser,0)              // macro for rootcint
 };
index f213cf2469b2f0959bfaeac82e0e53108cdb1e98..499d25ea371abe527bd3757eb4502e74c7d108c2 100644 (file)
@@ -8,43 +8,45 @@
 //_____________________________________________________________
 //
 // Description: constants for the flow makers and the flow analysis
+//  bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla  
+//  bla bla bla bla bla bla bla bla bla bla bla bla bla bla ...
 //
 // Original Authors:                 Art Poskanzer & Raimond Snellings
 //
 
 #include "AliFlowConstants.h"
 
-ClassImp(Flow)
+ClassImp(AliFlowConstants)
   
-  Float_t  Flow::fEtaMin    = -2. ;
-  Float_t  Flow::fEtaMax    =  2. ;
-  Float_t  Flow::fPtMin     =  0. ;
-  Float_t  Flow::fPtMax     = 10. ;
-  Float_t  Flow::fPtMaxPart =  5. ;
-  Float_t  Flow::fPtWgtSaturation =  5. ;
-  Float_t  Flow::fEtaMinTpcOnly = -0.9 ;
-  Float_t  Flow::fEtaMaxTpcOnly =  0.9 ;
+  Float_t  AliFlowConstants::fgEtaMin    = -2. ;
+  Float_t  AliFlowConstants::fgEtaMax    =  2. ;
+  Float_t  AliFlowConstants::fgPtMin     =  0. ;
+  Float_t  AliFlowConstants::fgPtMax     = 10. ;
+  Float_t  AliFlowConstants::fgPtMaxPart =  5. ;
+  Float_t  AliFlowConstants::fgPtWgtSaturation =  5. ;
+  Float_t  AliFlowConstants::fgEtaMinTpcOnly = -0.9 ;
+  Float_t  AliFlowConstants::fgEtaMaxTpcOnly =  0.9 ;
 
-  Float_t  Flow::fEtaMid = 0.5 ;
-  Float_t  Flow::fEtaGood = 0.9 ;
-  Float_t  Flow::fMaxMult = 2900. ; // Maximum expected multiplicity (now hijing)
-  Float_t  Flow::fCentNorm[nCents] = {0.0205,0.044,0.08,0.133,0.203,0.301,0.462,0.596,0.707} ;
-  Int_t    Flow::fCent0[nCents]  = {50,100,200,500,1000,2000,5000,8000,10000} ;
-  Double_t Flow::fBayesian[nPid] = {1.,1.,1.,1.,1.,1.} ;
+  Float_t  AliFlowConstants::fgEtaMid = 0.5 ;
+  Float_t  AliFlowConstants::fgEtaGood = 0.9 ;
+  Float_t  AliFlowConstants::fgMaxMult = 2000. ;   // Maximum expected multiplicity (for fgCentNorm)
+  Float_t  AliFlowConstants::fgCentNorm[kCents] = {0.0205,0.044,0.08,0.133,0.203,0.301,0.462,0.596,0.707} ;
+  Int_t    AliFlowConstants::fgCent0[kCents]  = {50,100,200,500,1000,2000,5000,8000,10000} ;
+  Double_t AliFlowConstants::fgBayesian[kPid] = {1.,1.,1.,1.,1.,1.} ;
  
-  Double_t Flow::fMagneticField = 0.4 ;
-  Double_t Flow::fCenterOfMassEnergy = 5500. ;
-  Short_t  Flow::fBeamMassNumberEast = 208 ;
-  Short_t  Flow::fBeamMassNumberWest = 208 ;
+  Double_t AliFlowConstants::fgMagneticField = 0.4 ;
+  Double_t AliFlowConstants::fgCenterOfMassEnergy = 5500. ;
+  Short_t  AliFlowConstants::fgBeamMassNumberEast = 208 ;
+  Short_t  AliFlowConstants::fgBeamMassNumberWest = 208 ;
 
-  Float_t  Flow::fITSx = 15. ;         // SDD (?) where dE/dx is measured
-  Float_t  Flow::fTPCx = 84.5 ;                // TPC (?) inner wall
-  Float_t  Flow::fTRDx = 294.5 ;       // TRD first plate
-  Float_t  Flow::fTOFx = 370. ;                // TOF (?)
+  Float_t  AliFlowConstants::fgITSx = 15. ;       // SDD where dE/dx is measured
+  Float_t  AliFlowConstants::fgTPCx = 84.5 ;     // TPC inner wall
+  Float_t  AliFlowConstants::fgTRDx = 294.5 ;    // TRD first plate
+  Float_t  AliFlowConstants::fgTOFx = 370. ;     // TOF 
 
-  Int_t    Flow::fMClabel = 10000 ;              // mcLabel < 0 --> not used
-  Bool_t   Flow::fDebug = kFALSE ;
+  Int_t    AliFlowConstants::fgMClabel = 10000 ;  // mcLabel < 0 --> not used
+  Bool_t   AliFlowConstants::fgDebug = kFALSE ;
   
-  Float_t  Flow::fMaxInt = 1000. ;
+  Float_t  AliFlowConstants::fgMaxInt = 1000. ;
 
 //////////////////////////////////////////////////////////////////////
index e0f85f95ac96d3c70643792bec4459465db5fdf4..5ba3b31e1b70708d49685fe5ef79af270d267a89 100644 (file)
@@ -7,78 +7,78 @@
 //////////////////////////////////////////////////////////////////////
 //
 // Description: constants for the flow makers
+//  bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla  
+//  bla bla bla bla bla bla bla bla bla bla bla bla bla bla ...
 //
 // Original Authors:                 Art Poskanzer & Raimond Snellings
 //
 //////////////////////////////////////////////////////////////////////
 
-#ifndef AliFlowConstants_h
-#define AliFlowConstants_h
+#ifndef ALIFLOWCONSTANTS_H
+#define ALIFLOWCONSTANTS_H
 
 #include <TROOT.h>
 
-class Flow {
+class AliFlowConstants {
 
  public:
 
   enum {
-    nHars        =   2,                                        // number of harmonics (>= 2)
-    nSels        =   2,                                        // number of selections (for each harmonics) 
-    nSubs        =   2,                                        // number of sub-events
-    nPhiBins     = 360,                                        // number of phi bins in weighting histograms
-    nEtaBins     = 100,                                                // number of eta bins in FlowAnalysis histograms
-    nPtBins      = 100,                                                // number of pT bins in FlowAnalysis histograms
-    nPtBinsPart  = 100,                                                // number of pT bins in flow histograms
-    nCumulIntegOrders =   3,                                   // order of the cumulant analysis
-    nCumulInteg_qMax  =   8,                                   // ..
-    nCumulDiffOrders  =   2,                                   // ..
-    nCumulDiff_qMax   =   8,                                   // ..
-    nCents       = 9,                                          // total number of centrality classes
-    nPid         = 6                                           // total number of p.id. hypotesis
+    kHars        =   2,                                        // number of harmonics (>= 2)
+    kSels        =   2,                                        // number of selections (for each harmonics) 
+    kSubs        =   2,                                        // number of sub-events
+    kPhiBins     = 360,                                        // number of phi bins in weighting histograms
+    kEtaBins     = 100,                                                // number of eta bins in FlowAnalysis histograms
+    kPtBins      = 100,                                                // number of pT bins in FlowAnalysis histograms
+    kPtBinsPart  = 100,                                                // number of pT bins in flow histograms
+    kCumulIntegOrders = 3,                                     // order of the cumulant analysis
+    kCumulIntegQmax   = 8,                                     // ..
+    kCumulDiffOrders  = 2,                                     // ..
+    kCumulDiffQmax    = 8,                                     // ..
+    kCents       = 9,                                          // total number of centrality classes
+    kPid         = 6                                           // total number of p.id. hypotesis
   };
 
-  typedef Double_t PhiWgt_t[nSels][nHars][nPhiBins];           // intermediate type to import weights from histograms' file 
+  typedef Double_t PhiWgt_t[kSels][kHars][kPhiBins];           // intermediate type to import weights from histograms' file 
 
-  static Int_t   fMClabel ;                                    // checking the simulation: pTrack->Label()<fMClabel = primary track 
-  static Bool_t  fDebug ;                                      // for more cout statements (debugging purpose)
+  static Int_t   fgMClabel ;                                   // checking the simulation: pTrack->Label()<fMClabel = primary track 
+  static Bool_t  fgDebug ;                                     // for more cout statements (debugging purpose)
 
  // Histograms limits
-  static Float_t fEtaMin ;                                     // eta lower limit for FlowAnalysis histograms
-  static Float_t fEtaMax ;                                     // eta upper limit for FlowAnalysis histograms
-  static Float_t fPtMin ;                                      // pT lower limit for FlowAnalysis histograms
-  static Float_t fPtMax ;                                      // pT upper limit for yield histograms
-  static Float_t fPtMaxPart ;                                  // pT upper limit for flow histograms
-  static Float_t fPtWgtSaturation ;                            // flow(pT) saturation value
-  static Float_t fEtaMinTpcOnly ;                              // eta lower limit of the full TPC acceptance (unused)
-  static Float_t fEtaMaxTpcOnly ;                              // eta upper limit of the full TPC acceptance (unused)
+  static Float_t fgEtaMin ;                                    // eta lower limit for FlowAnalysis histograms
+  static Float_t fgEtaMax ;                                    // eta upper limit for FlowAnalysis histograms
+  static Float_t fgPtMin ;                                     // pT lower limit for FlowAnalysis histograms
+  static Float_t fgPtMax ;                                     // pT upper limit for yield histograms
+  static Float_t fgPtMaxPart ;                                 // pT upper limit for flow histograms
+  static Float_t fgPtWgtSaturation ;                           // flow(pT) saturation value
+  static Float_t fgEtaMinTpcOnly ;                             // eta lower limit of the full TPC acceptance (unused)
+  static Float_t fgEtaMaxTpcOnly ;                             // eta upper limit of the full TPC acceptance (unused)
 
  // Centrality Measurement
-  static Float_t  fEtaMid ;                                    // Mid-Rapidity interval, used for Centrality measurement
-  static Float_t  fEtaGood ;                                   // Good Rapidity interval (TPC acceptance)
-  static Int_t    fCent0[Flow::nCents] ;                       // Expected Multiplicity for each Centrality class
-  static Double_t fBayesian[Flow::nPid] ;                      // Expected particles' abundance
-  static Float_t  fCentNorm[Flow::nCents] ;                    // Normalized Multiplicity for each Centrality class
-  static Float_t  fMaxMult ;                                   // Maximum expected multiplicity
+  static Float_t  fgEtaMid ;                                   // Mid-Rapidity interval, used for Centrality measurement
+  static Float_t  fgEtaGood ;                                  // Good Rapidity interval (TPC acceptance)
+  static Int_t    fgCent0[AliFlowConstants::kCents] ;          // Expected Multiplicity for each Centrality class
+  static Double_t fgBayesian[AliFlowConstants::kPid] ;         // Expected particles' abundance
+  static Float_t  fgCentNorm[AliFlowConstants::kCents] ;       // Normalized Multiplicity for each Centrality class
+  static Float_t  fgMaxMult ;                                  // Maximum expected multiplicity
 
  // Experimental Conditions
-  static Double_t fMagneticField;                              // magnetic field value (0.4 Tesla)
-  static Double_t fCenterOfMassEnergy;                         // center of mass energy (5.5 TeV)
-  static Short_t  fBeamMassNumberEast;                         // beam mass (Pb = 208)
-  static Short_t  fBeamMassNumberWest;                         // beam mass (Pb = 208)
+  static Double_t fgMagneticField;                             // magnetic field value (0.4 Tesla)
+  static Double_t fgCenterOfMassEnergy;                        // center of mass energy (5.5 TeV)
+  static Short_t  fgBeamMassNumberEast;                        // beam mass (Pb = 208)
+  static Short_t  fgBeamMassNumberWest;                        // beam mass (Pb = 208)
 
  // ALICE detector measures ...
-  static Float_t fITSx ;                                       // inner ITS radial distance from the interaction point
-  static Float_t fTPCx ;                                       // inner TPC radial distance from the interaction point 
-  static Float_t fTRDx ;                                       // inner TRD radial distance from the interaction point 
-  static Float_t fTOFx ;                                       // inner TOF radial distance from the interaction point 
+  static Float_t fgITSx ;                                      // inner ITS radial distance from the interaction point
+  static Float_t fgTPCx ;                                      // inner TPC radial distance from the interaction point 
+  static Float_t fgTRDx ;                                      // inner TRD radial distance from the interaction point 
+  static Float_t fgTOFx ;                                      // inner TOF radial distance from the interaction point 
 
-  static Float_t  fMaxInt ;                                    // big number (to avoid infinity)
+  static Float_t fgMaxInt ;                                    // big number (to avoid infinity)
 
-  ClassDef(Flow,1)                                             // macro for rootcint
+  ClassDef(AliFlowConstants,1)                                 // macro for rootcint
 };
 
-typedef Flow AliFlowConstants; //PK: Make rootcint happy, class name=file name
-
 #endif
 
 //////////////////////////////////////////////////////////////////////
index 8d9bf2d0bd02806a8295943ccab24eb51ee712f1..ccdb7f6c79e1919aaf068640464144737cd03647 100644 (file)
@@ -71,11 +71,11 @@ AliFlowEvent::AliFlowEvent(Int_t lenght)
  fV0Collection =  new TObjArray(0) ;
  
  // Set Weights Arrays to 1 (default)
- for(int nS=0;nS<Flow::nSels;nS++)
+ for(int nS=0;nS<AliFlowConstants::kSels;nS++)
  {
-  for(int nH=0;nH<Flow::nHars;nH++) 
+  for(int nH=0;nH<AliFlowConstants::kHars;nH++) 
   {
-   for(int nP=0;nP<Flow::nPhiBins;nP++) 
+   for(int nP=0;nP<AliFlowConstants::kPhiBins;nP++) 
    { 
     // enable this with: SetOnePhiWgt()  
     fPhiWgt[nS][nH][nP] = 1.     ; // cout << nS << nH << nP << "  val  " << fPhiWgt[nS][nH][nP] << endl ; 
@@ -86,9 +86,9 @@ AliFlowEvent::AliFlowEvent(Int_t lenght)
    }
   }
  }
- //for(int nH=0;nH<Flow::nHars;nH++) { fExtPsi[nH] = 0. ; fExtRes[nH] = 0. ; }
+ //for(int nH=0;nH<AliFlowConstants::kHars;nH++) { fExtPsi[nH] = 0. ; fExtRes[nH] = 0. ; }
  
- // The Expected particles abundance is taken directly from Flow::fBayesian[] (see Bayesian P.Id.)
+ // The Expected particles abundance is taken directly from AliFlowConstants::fgBayesian[] (see Bayesian P.Id.)
  
  fDone = kFALSE ;
 }
@@ -109,7 +109,7 @@ Double_t AliFlowEvent::PhiWeightRaw(Int_t selN, Int_t harN, AliFlowTrack* pFlowT
 
  float phi = pFlowTrack->Phi() ; if(phi < 0.) { phi += 2*TMath::Pi() ; }
  Double_t  eta = (Double_t)pFlowTrack->Eta() ;
- int n = (int)((phi/(2*TMath::Pi()))*Flow::nPhiBins);
+ int n = (int)((phi/(2*TMath::Pi()))*AliFlowConstants::kPhiBins);
 
  Double_t phiWgt = 1. ;
  if(OnePhiWgt()) 
@@ -132,14 +132,14 @@ Double_t AliFlowEvent::Weight(Int_t selN, Int_t harN, AliFlowTrack* pFlowTrack)
 { 
  // Weight for enhancing the resolution (eta gives sign +/- for Odd Harmonics)
 
- if(selN>Flow::nSels) { selN = 0 ; }
+ if(selN>AliFlowConstants::kSels) { selN = 0 ; }
  bool oddHar = (harN+1) % 2 ;
  Double_t phiWgt = 1. ;
  if(PtWgt()) 
  {
   Double_t pt = (Double_t)pFlowTrack->Pt();
-  if(pt < Flow::fPtWgtSaturation) { phiWgt *= pt ; } 
-  else                                   { phiWgt *= Flow::fPtWgtSaturation ; } // pt weighting going constant
+  if(pt < AliFlowConstants::fgPtWgtSaturation) { phiWgt *= pt ; } 
+  else                                   { phiWgt *= AliFlowConstants::fgPtWgtSaturation ; } // pt weighting going constant
  }
  Double_t eta = (Double_t)pFlowTrack->Eta();
  Double_t etaAbs = TMath::Abs(eta);
@@ -163,7 +163,7 @@ Double_t AliFlowEvent::PhiWeight(Int_t selN, Int_t harN, AliFlowTrack* pFlowTrac
  } 
  Double_t phiWgtRaw = PhiWeightRaw(selN, harN, pFlowTrack);
  Double_t weight = Weight(selN, harN, pFlowTrack);
- if(Flow::fDebug) { cout << "[PhiWeight]: phiWgtRaw = " << phiWgtRaw << " , weight = " << weight << " , eta = " << pFlowTrack->Eta() << endl ; }
+ if(AliFlowConstants::fgDebug) { cout << "[PhiWeight]: phiWgtRaw = " << phiWgtRaw << " , weight = " << weight << " , eta = " << pFlowTrack->Eta() << endl ; }
 
  return phiWgtRaw * weight;
 }
@@ -241,7 +241,7 @@ TVector2 AliFlowEvent::Q(AliFlowSelection* pFlowSelect)
    float phi = pFlowTrack->Phi();                      
    mQx += phiWgt * cos(phi * order) ;
    mQy += phiWgt * sin(phi * order) ;
-   if(Flow::fDebug) { cout << itr << " phi = " << phi << " ,  wgt = " << phiWgt << endl ; }
+   if(AliFlowConstants::fgDebug) { cout << itr << " phi = " << phi << " ,  wgt = " << phiWgt << endl ; }
   }
  }
  mQ.Set(mQx, mQy);
@@ -502,7 +502,7 @@ void AliFlowEvent::SetSelections(AliFlowSelection* pFlowSelect)
   pFlowTrack->ResetSelection() ;               // this re-sets all the mSelection flags to 0
 
  // * this sets all the selection n.[0] flag kTRUE (all harmonics) *
-  for(int harN=0;harN<Flow::nHars;harN++) { pFlowTrack->SetSelect(harN,0) ; } 
+  for(int harN=0;harN<AliFlowConstants::kHars;harN++) { pFlowTrack->SetSelect(harN,0) ; } 
 
  // Track need to be Constrainable
   if(pFlowSelect->ConstrainCut() && !pFlowTrack->IsConstrainable()) continue ;
@@ -531,12 +531,12 @@ void AliFlowEvent::SetSelections(AliFlowSelection* pFlowSelect)
   if((pFlowSelect->DcaGlobalCutHi()>pFlowSelect->DcaGlobalCutLo()) && (gDca<pFlowSelect->DcaGlobalCutLo() || gDca>pFlowSelect->DcaGlobalCutHi())) continue ;
 
  // Pt & Eta - this is done differently for different Harmonic & Selection
-  for(int selN = 1; selN < Flow::nSels; selN++)               // not even consider the 0th selection (no cut applied there)
+  for(int selN = 1; selN < AliFlowConstants::kSels; selN++)               // not even consider the 0th selection (no cut applied there)
   {
   // min. TPC hits required
    if(pFlowSelect->NhitsCut(selN) && (pFlowTrack->FitPtsTPC()<pFlowSelect->NhitsCut(selN))) continue ;
 
-   for(int harN = 0; harN < Flow::nHars; harN++) 
+   for(int harN = 0; harN < AliFlowConstants::kHars; harN++) 
    {
    // Eta - gets rid of the track with Eta outside the range
     if((pFlowSelect->EtaCutHi(harN%2,selN)>pFlowSelect->EtaCutLo(harN%2,selN)) && (TMath::Abs(eta)<pFlowSelect->EtaCutLo(harN%2,selN) || TMath::Abs(eta)>pFlowSelect->EtaCutHi(harN%2,selN))) continue ; 
@@ -545,7 +545,7 @@ void AliFlowEvent::SetSelections(AliFlowSelection* pFlowSelect)
   
     pFlowTrack->SetSelect(harN, selN) ;  // if cuts defined (low<high) && track is in the range -> Set [har][sel] Flag ON
 
-    if(Flow::fDebug) 
+    if(AliFlowConstants::fgDebug) 
     {
      cout << " harN " << harN%2 << " ,  selN " << selN << " - si" << endl ;
      if(pFlowSelect->Pid()[0] != '\0') { cout << " track:  pid  " << pFlowTrack->Pid() << " = "<< pFlowSelect->Pid() << endl ; } 
@@ -561,7 +561,7 @@ void AliFlowEvent::SetSelections(AliFlowSelection* pFlowSelect)
 //-------------------------------------------------------------
 void AliFlowEvent::SetPids()
 {
- // Re-sets the tracks P.id. (using the current Flow::fBayesian[] array)
+ // Re-sets the tracks P.id. (using the current AliFlowConstants::fgBayesian[] array)
  
  const Int_t code[] = {11,13,211,321,2212,10010020} ;
  for(Int_t itr=0;itr<TrackCollection()->GetEntries();itr++) 
@@ -571,7 +571,7 @@ void AliFlowEvent::SetPids()
   TVector bayPid = pFlowTrack->PidProbs() ;
   Int_t maxN = 2 ;                // if No id. -> then is a Pi
   Float_t pid_max = bayPid[2] ;    // (if all equal, Pi probability get's the advantage to be the first)
-  for(Int_t nP=0;nP<Flow::nPid;nP++)
+  for(Int_t nP=0;nP<AliFlowConstants::kPid;nP++)
   {
    if(bayPid[nP]>pid_max) { maxN = nP ; pid_max = bayPid[nP] ; }
   }
@@ -592,7 +592,7 @@ void AliFlowEvent::MakeRndSubEvents()
 {
  // Make random subevents
  
- int eventMult[Flow::nHars][Flow::nSels] = {{0}};
+ int eventMult[AliFlowConstants::kHars][AliFlowConstants::kSels] = {{0}};
  int harN, selN, subN = 0;
  
  // loop to count the total number of tracks for each selection
@@ -600,20 +600,20 @@ void AliFlowEvent::MakeRndSubEvents()
  {
   AliFlowTrack* pFlowTrack ;
   pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
-  for (selN = 0; selN < Flow::nSels; selN++) 
+  for (selN = 0; selN < AliFlowConstants::kSels; selN++) 
   {
-   for (harN = 0; harN < Flow::nHars; harN++) 
+   for (harN = 0; harN < AliFlowConstants::kHars; harN++) 
    {
     if(pFlowTrack->Select(harN, selN)) { eventMult[harN][selN]++ ; }
    }
   }
  }
  // loop to set the SubEvent member
- for (selN = 0; selN < Flow::nSels; selN++) 
+ for (selN = 0; selN < AliFlowConstants::kSels; selN++) 
  {
-  for (harN = 0; harN < Flow::nHars; harN++) 
+  for (harN = 0; harN < AliFlowConstants::kHars; harN++) 
   {
-   int subEventMult = eventMult[harN][selN] / Flow::nSubs;
+   int subEventMult = eventMult[harN][selN] / AliFlowConstants::kSubs;
    if (subEventMult) 
    {
     subN = 0;
@@ -642,9 +642,9 @@ void AliFlowEvent::MakeEtaSubEvents()
  
  int harN, selN = 0;
  // loop to set the SubEvent member
- for (selN = 0; selN < Flow::nSels; selN++) 
+ for (selN = 0; selN < AliFlowConstants::kSels; selN++) 
  {
-  for (harN = 0; harN < Flow::nHars; harN++) 
+  for (harN = 0; harN < AliFlowConstants::kHars; harN++) 
   {
    for(Int_t itr=0;itr<TrackCollection()->GetEntries();itr++) 
    {
@@ -685,7 +685,7 @@ void AliFlowEvent::RandomShuffle()
    if(!newTrackCollection->At(rndNumber)) 
    { 
     newTrackCollection->AddAt(pFlowTrack, rndNumber) ; 
-    put = kTRUE ; tot++ ;              if(Flow::fDebug) { cout << "  " << itr << " --> " << rndNumber << endl ; } 
+    put = kTRUE ; tot++ ;              if(AliFlowConstants::fgDebug) { cout << "  " << itr << " --> " << rndNumber << endl ; } 
    }
    else 
    {
@@ -693,7 +693,7 @@ void AliFlowEvent::RandomShuffle()
    }
   }
  }
- if(Flow::fDebug) { cout << "* RandomShuffle() :  " << tot << "/" << imax << " flow tracks have been shuffled " << endl ; }  
+ if(AliFlowConstants::fgDebug) { cout << "* RandomShuffle() :  " << tot << "/" << imax << " flow tracks have been shuffled " << endl ; }  
  fTrackCollection = newTrackCollection ;
 }
 //-----------------------------------------------------------------------
@@ -722,24 +722,24 @@ void AliFlowEvent::SetCentrality()
 
  if(RunID() == -1)
  { 
-  cent = Flow::fCentNorm ;
+  cent = AliFlowConstants::fgCentNorm ;
   //if centrality classes are not defined, does it now (with CentNorm & MaxMult)
-  if(cent[Flow::nCents-1] <= 1) 
+  if(cent[AliFlowConstants::kCents-1] <= 1) 
   {
-   for(Int_t ic=0;ic<Flow::nCents;ic++)
+   for(Int_t ic=0;ic<AliFlowConstants::kCents;ic++)
    {
-    cent[ic] *= Flow::fMaxMult ; 
-    if(Flow::fDebug) { cout << "Centrality[" << ic << "] = " << cent[ic] << " . " << endl ; }
+    cent[ic] *= AliFlowConstants::fgMaxMult ; 
+    if(AliFlowConstants::fgDebug) { cout << "Centrality[" << ic << "] = " << cent[ic] << " . " << endl ; }
    }
   }
  }
  else if((RunID() != -1) && (CenterOfMassEnergy() == 5500.))
  {
-  cent = (Float_t*)Flow::fCent0 ;
+  cent = (Float_t*)AliFlowConstants::fgCent0 ;
  } 
  else // other definition of centrality are possible...
  {
-  cent = (Float_t*)Flow::fCent0 ;
+  cent = (Float_t*)AliFlowConstants::fgCent0 ;
  } 
  if      (tracks < cent[0])  { fCentrality = 0; }
  else if (tracks < cent[1])  { fCentrality = 1; }
@@ -752,20 +752,20 @@ void AliFlowEvent::SetCentrality()
  else if (tracks < cent[8])  { fCentrality = 8; }
  else                        { fCentrality = 9; }
 
- if(Flow::fDebug) { cout << " * Centrality Class :  " << fCentrality << " . " << endl ; }
+ if(AliFlowConstants::fgDebug) { cout << " * Centrality Class :  " << fCentrality << " . " << endl ; }
 }
 //-----------------------------------------------------------------------
-void AliFlowEvent::Bayesian(Double_t bayes[Flow::nPid]) 
+void AliFlowEvent::Bayesian(Double_t bayes[AliFlowConstants::kPid]) 
 {
- // Returns bayesian array of particles' abundances (from Flow::)
+ // Returns bayesian array of particles' abundances (from AliFlowConstants::)
  
- for(Int_t i=0;i<Flow::nPid;i++) { bayes[i] = Flow::fBayesian[i] ; }
+ for(Int_t i=0;i<AliFlowConstants::kPid;i++) { bayes[i] = AliFlowConstants::fgBayesian[i] ; }
 }
 //-----------------------------------------------------------------------
 TVector AliFlowEvent::Bayesian() 
 { 
- TVector bayes(Flow::nPid) ; 
- for(Int_t i=0;i<Flow::nPid;i++) { bayes[i] = Flow::fBayesian[i] ; }
+ TVector bayes(AliFlowConstants::kPid) ; 
+ for(Int_t i=0;i<AliFlowConstants::kPid;i++) { bayes[i] = AliFlowConstants::fgBayesian[i] ; }
  return bayes ;
 }
 //-----------------------------------------------------------------------
@@ -778,7 +778,7 @@ void AliFlowEvent::PrintFlagList() const
  if(PtWgt()) 
  {
   cout << "#   PtWgt =  kTRUE " << endl ;      // (also for output of PhiWgt file?)
-  cout << "#   PtWgt Saturation =  " << Flow::fPtWgtSaturation << endl;
+  cout << "#   PtWgt Saturation =  " << AliFlowConstants::fgPtWgtSaturation << endl;
  } 
  else 
  {
@@ -808,7 +808,7 @@ void AliFlowEvent::SetEventID(const Int_t& id)
 //-----------------------------------------------------------------------
 Int_t AliFlowEvent::MultEta()
 {
- // Returns the multiplicity in the interval |eta|<(Flow::fEetaMid), used 
+ // Returns the multiplicity in the interval |eta|<(AliFlowConstants::fgEetaMid), used 
  // for centrality measurement (see centrality classes in fCentrality) .
  
  Int_t goodtracks = 0 ;
@@ -816,7 +816,7 @@ Int_t AliFlowEvent::MultEta()
  {
   AliFlowTrack* pFlowTrack ;
   pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
-  if((pFlowTrack->Charge()) && (TMath::Abs(pFlowTrack->Eta())<Flow::fEtaMid)) { goodtracks++ ; }
+  if((pFlowTrack->Charge()) && (TMath::Abs(pFlowTrack->Eta())<AliFlowConstants::fgEtaMid)) { goodtracks++ ; }
  }
  return goodtracks ; 
 }
@@ -824,7 +824,7 @@ Int_t AliFlowEvent::MultEta()
 Int_t AliFlowEvent::UncorrNegMult(Float_t eta)  const
 { 
  // Negative multiplicity in the interval (-eta..eta)
- // (default is  Flow::fEetaGood = 0.9)
+ // (default is  AliFlowConstants::fgEetaGood = 0.9)
  
  Int_t negMult = 0 ;
  for(Int_t itr=0;itr<TrackCollection()->GetEntries();itr++) 
@@ -840,7 +840,7 @@ Int_t AliFlowEvent::UncorrNegMult(Float_t eta)  const
 Int_t AliFlowEvent::UncorrPosMult(Float_t eta)  const
 { 
  // Positive multiplicity in the interval (-eta..eta)
- // (default is  Flow::fEetaGood = 0.9)
+ // (default is  AliFlowConstants::fgEetaGood = 0.9)
  
  Int_t posMult = 0 ;
  for(Int_t itr=0;itr<TrackCollection()->GetEntries();itr++) 
@@ -875,21 +875,21 @@ void AliFlowEvent::MakeAll()
  // calculates all quantities in 1 shoot ...
  //  ...
 
- Double_t mQx[Flow::nSels][Flow::nHars] ;
- Double_t mQy[Flow::nSels][Flow::nHars] ;
- Double_t mQxSub[Flow::nSubs][Flow::nSels][Flow::nHars] ;
- Double_t mQySub[Flow::nSubs][Flow::nSels][Flow::nHars] ;
+ Double_t mQx[AliFlowConstants::kSels][AliFlowConstants::kHars] ;
+ Double_t mQy[AliFlowConstants::kSels][AliFlowConstants::kHars] ;
+ Double_t mQxSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars] ;
+ Double_t mQySub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars] ;
  // -
  int selN, harN, subN ;
- for(selN=0;selN<Flow::nSels;selN++) 
+ for(selN=0;selN<AliFlowConstants::kSels;selN++) 
  {
-  for(harN=0;harN<Flow::nHars;harN++) 
+  for(harN=0;harN<AliFlowConstants::kHars;harN++) 
   {
    mQx[selN][harN]    = 0. ;   
    mQy[selN][harN]    = 0. ;   
    fMult[selN][harN]  = 0 ;    
    fSumOfWeightSqr[selN][harN] = 0. ;
-   for(subN=0;subN<Flow::nSubs;subN++)
+   for(subN=0;subN<AliFlowConstants::kSubs;subN++)
    {
     mQxSub[subN][selN][harN]   = 0. ;
     mQySub[subN][selN][harN]   = 0. ;
@@ -908,9 +908,9 @@ void AliFlowEvent::MakeAll()
   AliFlowTrack* pFlowTrack ;
   pFlowTrack = (AliFlowTrack*)TrackCollection()->At(itr) ;
   phi = pFlowTrack->Phi();
-  for(selN=0;selN<Flow::nSels;selN++) 
+  for(selN=0;selN<AliFlowConstants::kSels;selN++) 
   {
-   for(harN=0;harN<Flow::nHars;harN++) 
+   for(harN=0;harN<AliFlowConstants::kHars;harN++) 
    {
     order = (double)(harN+1) ;
     if(pFlowTrack->Select(harN,selN)) 
@@ -920,7 +920,7 @@ void AliFlowEvent::MakeAll()
      mQx[selN][harN] += phiWgt * cos(phi * order) ;
      mQy[selN][harN] += phiWgt * sin(phi * order) ;
      fMult[selN][harN]++ ;     
-     for(subN=0;subN<Flow::nSubs;subN++)
+     for(subN=0;subN<AliFlowConstants::kSubs;subN++)
      {
       if(pFlowTrack->Select(harN,selN,subN))
       {
@@ -934,12 +934,12 @@ void AliFlowEvent::MakeAll()
   }  // sel
  }  //itr
 
- for(selN=0;selN<Flow::nSels;selN++)  
+ for(selN=0;selN<AliFlowConstants::kSels;selN++)  
  {
-  for(harN=0;harN<Flow::nHars;harN++)
+  for(harN=0;harN<AliFlowConstants::kHars;harN++)
   {
    fQ[selN][harN].Set(mQx[selN][harN],mQy[selN][harN]) ;  
-   for(subN=0;subN<Flow::nSubs;subN++) { fQSub[subN][selN][harN].Set(mQxSub[subN][selN][harN],mQySub[subN][selN][harN]) ; }
+   for(subN=0;subN<AliFlowConstants::kSubs;subN++) { fQSub[subN][selN][harN].Set(mQxSub[subN][selN][harN],mQySub[subN][selN][harN]) ; }
   }
  }
 
@@ -950,7 +950,7 @@ void AliFlowEvent::MakeAll()
 // { 
 //  // external R.P. angle (check input source...)
 // 
-//  if(harN<Flow::nHars) { return fExtPsi[harN] ; }
+//  if(harN<AliFlowConstants::kHars) { return fExtPsi[harN] ; }
 //  else 
 //  { 
 //   cout << "AliFlowEvent::ExtPsi(" << harN << ") : harmonic " << harN+1 << " is not there !" << endl ; 
@@ -962,7 +962,7 @@ void AliFlowEvent::MakeAll()
 // { 
 //  // external R.P. resolution (check input source...)
 // 
-//  if(harN<Flow::nHars) { return fExtRes[harN] ; }
+//  if(harN<AliFlowConstants::kHars) { return fExtRes[harN] ; }
 //  else 
 //  { 
 //   cout << "AliFlowEvent::ExtRes(" << harN << ") : harmonic " << harN+1 << " is not there !" << endl ; 
@@ -972,12 +972,12 @@ void AliFlowEvent::MakeAll()
 // //-----------------------------------------------------------------------
 // void AliFlowEvent::SetExtPsi(Int_t harN,Float_t psi)         
 // { 
-//  if(harN<Flow::nHars) { fExtPsi[harN] = psi ; }
+//  if(harN<AliFlowConstants::kHars) { fExtPsi[harN] = psi ; }
 // }
 // //-----------------------------------------------------------------------
 // void AliFlowEvent::SetExtRes(Int_t harN,Float_t res)         
 // { 
-//  if(harN<Flow::nHars) { fExtRes[harN] = res ; }
+//  if(harN<AliFlowConstants::kHars) { fExtRes[harN] = res ; }
 // }
 // //-----------------------------------------------------------------------
 
@@ -991,17 +991,17 @@ TObjArray* AliFlowEvent::V0Collection() const             { return fV0Collection; }
 //-----------------------------------------------------------------------
 Int_t   AliFlowEvent::EventID() const                  { return fEventID; }
 Int_t   AliFlowEvent::RunID() const                    { return fRunID; }
-Double_t AliFlowEvent::CenterOfMassEnergy() const      { return Flow::fCenterOfMassEnergy ; }
-Double_t AliFlowEvent::MagneticField() const           { return Flow::fMagneticField ; }
-Short_t  AliFlowEvent::BeamMassNumberEast() const      { return Flow::fBeamMassNumberEast ; }
-Short_t  AliFlowEvent::BeamMassNumberWest() const      { return Flow::fBeamMassNumberWest ; }
+Double_t AliFlowEvent::CenterOfMassEnergy() const      { return AliFlowConstants::fgCenterOfMassEnergy ; }
+Double_t AliFlowEvent::MagneticField() const           { return AliFlowConstants::fgMagneticField ; }
+Short_t  AliFlowEvent::BeamMassNumberEast() const      { return AliFlowConstants::fgBeamMassNumberEast ; }
+Short_t  AliFlowEvent::BeamMassNumberWest() const      { return AliFlowConstants::fgBeamMassNumberWest ; }
 UInt_t   AliFlowEvent::OrigMult() const                { return fOrigMult; }
 Long_t   AliFlowEvent::L0TriggerWord() const           { return fL0TriggerWord; }
 Int_t    AliFlowEvent::V0Mult() const                  { return V0Collection()->GetEntries() ; }
 Int_t    AliFlowEvent::FlowEventMult() const           { return TrackCollection()->GetEntries() ; }
 Int_t    AliFlowEvent::ZDCpart() const                 { return fZDCpart; }
 Float_t  AliFlowEvent::ZDCenergy(Int_t npem) const     { return fZDCenergy[npem]; }
-Float_t  AliFlowEvent::PtWgtSaturation() const         { return Flow::fPtWgtSaturation; }
+Float_t  AliFlowEvent::PtWgtSaturation() const         { return AliFlowConstants::fgPtWgtSaturation; }
 Bool_t   AliFlowEvent::PtWgt() const                   { return fPtWgt; }
 Bool_t   AliFlowEvent::EtaWgt() const                  { return fEtaWgt; }
 Bool_t   AliFlowEvent::FirstLastPhiWgt() const         { return !fOnePhiWgt ; }
@@ -1011,18 +1011,18 @@ Bool_t   AliFlowEvent::EtaSubs() const                  { return fEtaSubs ; }
 //-----------------------------------------------------------------------
 void            AliFlowEvent::SetEtaSubs(Bool_t etasub)                      { fEtaSubs = etasub ; }
 void    AliFlowEvent::SetRunID(const Int_t& id)                      { fRunID = id; }
-void    AliFlowEvent::SetMagneticField(const Double_t& mf)           { Flow::fMagneticField = mf; }
-void    AliFlowEvent::SetCenterOfMassEnergy(const Double_t& cms)     { Flow::fCenterOfMassEnergy = cms; }
-void    AliFlowEvent::SetBeamMassNumberEast(const Short_t& bme)      { Flow::fBeamMassNumberEast = bme; }
-void    AliFlowEvent::SetBeamMassNumberWest(const Short_t& bmw)      { Flow::fBeamMassNumberWest = bmw; }
+void    AliFlowEvent::SetMagneticField(const Double_t& mf)           { AliFlowConstants::fgMagneticField = mf; }
+void    AliFlowEvent::SetCenterOfMassEnergy(const Double_t& cms)     { AliFlowConstants::fgCenterOfMassEnergy = cms; }
+void    AliFlowEvent::SetBeamMassNumberEast(const Short_t& bme)      { AliFlowConstants::fgBeamMassNumberEast = bme; }
+void    AliFlowEvent::SetBeamMassNumberWest(const Short_t& bmw)      { AliFlowConstants::fgBeamMassNumberWest = bmw; }
 void    AliFlowEvent::SetOrigMult(const UInt_t& tracks)              { fOrigMult = tracks; }
 void    AliFlowEvent::SetL0TriggerWord(const Long_t& trigger)        { fL0TriggerWord = trigger; }
 void    AliFlowEvent::SetZDCpart(Int_t zdcp)                         { fZDCpart = zdcp ; }
 void    AliFlowEvent::SetZDCenergy(Float_t n, Float_t p, Float_t em) { fZDCenergy[0] = n ; fZDCenergy[1] = p ; fZDCenergy[2] = em ; }
 //-----------------------------------------------------------------------
-void AliFlowEvent::SetBayesian(Double_t bayes[Flow::nPid])       
+void AliFlowEvent::SetBayesian(Double_t bayes[AliFlowConstants::kPid])           
 { 
- for(Int_t i=0;i<Flow::nPid;i++) { Flow::fBayesian[i] = bayes[i] ; } 
+ for(Int_t i=0;i<AliFlowConstants::kPid;i++) { AliFlowConstants::fgBayesian[i] = bayes[i] ; } 
 }
 //-----------------------------------------------------------------------
 void AliFlowEvent::SetNoWgt(Bool_t nowgt) 
@@ -1038,10 +1038,10 @@ void AliFlowEvent::SetPtWgt(Bool_t PtWgt)                         { fPtWgt = PtWgt; }
 void AliFlowEvent::SetEtaWgt(Bool_t EtaWgt)                      { fEtaWgt = EtaWgt; }
 //-----------------------------------------------------------------------
 #ifndef __CINT__
-void AliFlowEvent::SetPhiWeight(const Flow::PhiWgt_t& pPhiWgt)          { memcpy (fPhiWgt, pPhiWgt, sizeof(Flow::PhiWgt_t)); }
-void AliFlowEvent::SetPhiWeightPlus(const Flow::PhiWgt_t& pPhiWgtPlus)   { memcpy (fPhiWgtPlus,  pPhiWgtPlus,  sizeof(Flow::PhiWgt_t)); }
-void AliFlowEvent::SetPhiWeightMinus(const Flow::PhiWgt_t& pPhiWgtMinus) { memcpy (fPhiWgtMinus, pPhiWgtMinus, sizeof(Flow::PhiWgt_t)); }
-void AliFlowEvent::SetPhiWeightCross(const Flow::PhiWgt_t& pPhiWgtCross) { memcpy (fPhiWgtCross, pPhiWgtCross, sizeof(Flow::PhiWgt_t)); }
+void AliFlowEvent::SetPhiWeight(const AliFlowConstants::PhiWgt_t& pPhiWgt)          { memcpy (fPhiWgt, pPhiWgt, sizeof(AliFlowConstants::PhiWgt_t)); }
+void AliFlowEvent::SetPhiWeightPlus(const AliFlowConstants::PhiWgt_t& pPhiWgtPlus)   { memcpy (fPhiWgtPlus,  pPhiWgtPlus,  sizeof(AliFlowConstants::PhiWgt_t)); }
+void AliFlowEvent::SetPhiWeightMinus(const AliFlowConstants::PhiWgt_t& pPhiWgtMinus) { memcpy (fPhiWgtMinus, pPhiWgtMinus, sizeof(AliFlowConstants::PhiWgt_t)); }
+void AliFlowEvent::SetPhiWeightCross(const AliFlowConstants::PhiWgt_t& pPhiWgtCross) { memcpy (fPhiWgtCross, pPhiWgtCross, sizeof(AliFlowConstants::PhiWgt_t)); }
 #endif
 //-----------------------------------------------------------------------
 //////////////////////////////////////////////////////////////////////
index 3324d07d7a35ff1a958963b43359b90550e86053..502c7babda158675edeadf0cc3e71a169d979c84 100644 (file)
@@ -33,7 +33,6 @@
 class AliFlowTrack ;
 class AliFlowV0 ;
 class AliFlowSelection ;
-class Flow ;
 
 class AliFlowEvent : public TNamed {
 
@@ -54,9 +53,9 @@ public:
   UInt_t         OrigMult()            const;                                  // Returns the original number of tracks (maybe some were trown away)
   Int_t         V0Mult()               const;                                  // Returns the number of V0s 
   Int_t          FlowEventMult()       const;                                  // Returns number of tracks stored in the event
-  Int_t          UncorrNegMult(Float_t eta = Flow::fEtaGood) const ;           // Returns number of - tracks in eta (-eta;eta)
-  Int_t          UncorrPosMult(Float_t eta = Flow::fEtaGood) const ;           // Returns number of + tracks in eta (-eta;eta)
-  Int_t          MultEta() ;                                                   // Returns multiplicity in |eta|<Flow::fEetaMid
+  Int_t          UncorrNegMult(Float_t eta = AliFlowConstants::fgEtaGood) const ; // Returns number of - tracks in eta (-eta;eta)
+  Int_t          UncorrPosMult(Float_t eta = AliFlowConstants::fgEtaGood) const ; // Returns number of + tracks in eta (-eta;eta)
+  Int_t          MultEta() ;                                                   // Returns multiplicity in |eta|<AliFlowConstants::fgEetaMid
   Double_t       CenterOfMassEnergy()  const;                                  // Returns center of mass energy (5.5 TeV)
   Double_t       MagneticField()       const;                                  // Returns magnetic field value
   Short_t        BeamMassNumberEast()  const;                                  // Returns beam mass (Pb = 208)
@@ -120,7 +119,7 @@ public:
   Double_t       PhiWeight(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ;     // Returns PhiWeightRaw()*Weight()  
   Double_t       PhiWeightRaw(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ;  // Returns weights for making the R.P. isotropic in the lab
   Double_t       Weight(Int_t selN,Int_t harN,AliFlowTrack* pFlowTrack) const ;        // Returns weights for enhancing the resolution (+/-Sign(eta) for odd harmonics)
-  void          Bayesian(Double_t bayes[Flow::nPid]) ;                         // Returns the stored particles' abundances
+  void          Bayesian(Double_t bayes[AliFlowConstants::kPid]) ;                     // Returns the stored particles' abundances
   TVector       Bayesian() ;                                                   // Returns the stored particles' abundances as a TVector
  // -
   static void   SetPtWgt(Bool_t PtWgt = kTRUE);
@@ -129,12 +128,12 @@ public:
   static void   SetFirstLastPhiWgt();
   static void   SetNoWgt(Bool_t nowgt = kTRUE) ;
  // -
-  void          SetBayesian(Double_t bayes[Flow::nPid]) ;                      // Set the Bayesian vector of particles' abundances
+  void          SetBayesian(Double_t bayes[AliFlowConstants::kPid]) ;                  // Set the Bayesian vector of particles' abundances
 #ifndef __CINT__               
-  void          SetPhiWeight(const Flow::PhiWgt_t &pPhiWgt);                   // Fills Weights from Arrays (from file: flowPhiWgt.hist.root)
-  void          SetPhiWeightPlus(const Flow::PhiWgt_t &pPhiWgtPlus);
-  void          SetPhiWeightMinus(const Flow::PhiWgt_t &pPhiWgtMinus);
-  void          SetPhiWeightCross(const Flow::PhiWgt_t &pPhiWgtCross);
+  void          SetPhiWeight(const AliFlowConstants::PhiWgt_t &pPhiWgt);                       // Fills Weights from Arrays (from file: flowPhiWgt.hist.root)
+  void          SetPhiWeightPlus(const AliFlowConstants::PhiWgt_t &pPhiWgtPlus);
+  void          SetPhiWeightMinus(const AliFlowConstants::PhiWgt_t &pPhiWgtMinus);
+  void          SetPhiWeightCross(const AliFlowConstants::PhiWgt_t &pPhiWgtCross);
 #endif
 
  // Analysis flags
@@ -156,19 +155,19 @@ private:
   Int_t               fCentrality;                               //! Centrality Class (calculated from mult.)
 
  // extension
-  //Float_t          fExtPsi[Flow::nHars] ;                     // external RP angle (should be an input)
-  //Float_t          fExtRes[Flow::nHars] ;                     // external RP resolution (should be an input as well)
+  //Float_t          fExtPsi[AliFlowConstants::kHars] ;                         // external RP angle (should be an input)
+  //Float_t          fExtRes[AliFlowConstants::kHars] ;                         // external RP resolution (should be an input as well)
 
  // Tracks & V0s
   TObjArray*         fTrackCollection ;                         // collection of Flow Tracks
   TObjArray*         fV0Collection ;                            // collection of Flow V0s
 
  // Weights
-  Flow::PhiWgt_t      fPhiWgt;                                   //! flattening weights (single hist)
-  Flow::PhiWgt_t      fPhiWgtPlus;                               //! flattening weights (3 hist) - plus Z
-  Flow::PhiWgt_t      fPhiWgtMinus;                              //! flattening weights (3 hist) - minus Z
-  Flow::PhiWgt_t      fPhiWgtCross;                              //! flattening weights (3 hist) - cross Z
-  //Double_t           fBayesianCs[Flow::nPid] ;                //! expected particles abundance (see Bayesian P.Id.)
+  AliFlowConstants::PhiWgt_t      fPhiWgt;                       //! flattening weights (single hist)
+  AliFlowConstants::PhiWgt_t      fPhiWgtPlus;                   //! flattening weights (3 hist) - plus Z
+  AliFlowConstants::PhiWgt_t      fPhiWgtMinus;                  //! flattening weights (3 hist) - minus Z
+  AliFlowConstants::PhiWgt_t      fPhiWgtCross;                  //! flattening weights (3 hist) - cross Z
+  //Double_t           fBayesianCs[AliFlowConstants::kPid] ;    //! expected particles abundance (see Bayesian P.Id.)
 
  // Weighting & Settings
   static Bool_t       fPtWgt;                                    //! flag for pt weighting
@@ -179,12 +178,12 @@ private:
 
 #ifndef __CINT__
  // shortcuts (to speed up the execution)
-  Bool_t   fDone ;                                             //! flag setted kTRUE when the loop is done
-  TVector2 fQ[Flow::nSels][Flow::nHars];                       //! flow vector
-  UInt_t   fMult[Flow::nSels][Flow::nHars];                    //! multiplicity
-  Float_t  fSumOfWeightSqr[Flow::nSels][Flow::nHars];           //! Sqrt(Sum(wgt)) ~ Sqrt(Mult)
-  TVector2 fQSub[Flow::nSubs][Flow::nSels][Flow::nHars];       //! flow vector subs
-  UInt_t   fMultSub[Flow::nSubs][Flow::nSels][Flow::nHars];    //! multiplicity subs
+  Bool_t   fDone ;                                                                                     //! flag setted kTRUE when the loop is done
+  TVector2 fQ[AliFlowConstants::kSels][AliFlowConstants::kHars];                                       //! flow vector
+  UInt_t   fMult[AliFlowConstants::kSels][AliFlowConstants::kHars];                                    //! multiplicity
+  Float_t  fSumOfWeightSqr[AliFlowConstants::kSels][AliFlowConstants::kHars];                                  //! Sqrt(Sum(wgt)) ~ Sqrt(Mult)
+  TVector2 fQSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars];           //! flow vector subs
+  UInt_t   fMultSub[AliFlowConstants::kSubs][AliFlowConstants::kSels][AliFlowConstants::kHars];        //! multiplicity subs
 #endif /*__CINT__*/
 
   ClassDef(AliFlowEvent,2) ;                    // macro for rootcint
index 00d5f8debcd66162218480013c0936b73eaf1401..b0f4a6383996ec6f813cb7bff2aa4b9d94f52778 100644 (file)
 // ROOT things
 #include <TROOT.h>
 #include <TFile.h>
-#include <TTree.h>
-#include <TChain.h>
 #include <TString.h>
-#include <TObject.h>
-#include <TObjArray.h>
-#include <TParticle.h>
-#include <TParticlePDG.h>
-#include <TDatabasePDG.h>
 
 // AliRoot things
 #include "AliESD.h"
 #include "AliESDVertex.h"
 #include "AliESDtrack.h"
 #include "AliESDv0.h"
-#include "AliKalmanTrack.h"
+//#include "AliKalmanTrack.h"
 
 // Flow things
 #include "AliFlowEvent.h"
 #include "AliFlowMaker.h"
 
 // ANSI things
-#include <math.h>
-#include <stdio.h>
 #include <stdlib.h>
-#include <iostream>
 using namespace std; //required for resolving the 'cout' symbol
 
 ClassImp(AliFlowMaker) 
@@ -122,9 +112,9 @@ AliFlowEvent* AliFlowMaker::FillFlowEvent(AliESD* fESD)
  // Run information (fixed - ???)
  fMagField = fESD->GetMagneticField() ; // cout << " *fMagField " << fMagField << endl ;
  fFlowEvent->SetMagneticField(fMagField) ;     
- fFlowEvent->SetCenterOfMassEnergy(Flow::fCenterOfMassEnergy) ;        
- fFlowEvent->SetBeamMassNumberEast(Flow::fBeamMassNumberEast) ;        
- fFlowEvent->SetBeamMassNumberWest(Flow::fBeamMassNumberWest) ;        
+ fFlowEvent->SetCenterOfMassEnergy(AliFlowConstants::fgCenterOfMassEnergy) ;   
+ fFlowEvent->SetBeamMassNumberEast(AliFlowConstants::fgBeamMassNumberEast) ;   
+ fFlowEvent->SetBeamMassNumberWest(AliFlowConstants::fgBeamMassNumberWest) ;   
 
  // Trigger information (now is: ULon64_t - some trigger mask)
  fFlowEvent->SetL0TriggerWord((Int_t)fESD->GetTriggerMask()); 
@@ -235,8 +225,8 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
   Float_t eta = (Float_t)Eta(cD) ; 
   fFlowTrack->SetEta(eta) ;                            
  
-  // number of constrainable tracks with |eta| < Flow::fEtaGood (0.9)
-  if(TMath::Abs(eta) < Flow::fEtaGood)  { fGoodTracksEta++ ; }
+  // number of constrainable tracks with |eta| < AliFlowConstants::fgEtaGood (0.9)
+  if(TMath::Abs(eta) < AliFlowConstants::fgEtaGood)  { fGoodTracksEta++ ; }
  }
  else  // in case Constriction impossible for track, fill the UnConstrained (global)
  {
@@ -247,10 +237,10 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  }          
 
  // positive - negative tracks
- Int_t trk_sign = (Int_t)fTrack->GetSign() ; 
- fFlowTrack->SetCharge(trk_sign) ;             
- if(trk_sign>0)        { fPosiTracks++ ; }
- else if(trk_sign<0)   { fNegaTracks++ ; }
+ Int_t trkSign = (Int_t)fTrack->GetSign() ; 
+ fFlowTrack->SetCharge(trkSign) ;              
+ if(trkSign>0)         { fPosiTracks++ ; }
+ else if(trkSign<0)    { fNegaTracks++ ; }
  else                  { return 0 ; }
 
  // Tracking parameters (fit , TPC , ITS , dE/dx)
@@ -266,8 +256,8 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  for(Int_t gg=0;gg<3;gg++) { pVecAt[gg] = gD[gg] ; }
  Bool_t boh ; Float_t pAt = 0 ;                        // to get p at each detector
  // -
- if(fNewAli) { boh = fTrack->GetPxPyPzAt(Flow::fTPCx, fMagField, pVecAt) ; }
- else       { boh = fTrack->GetInnerParam()->GetPxPyPzAt(Flow::fTPCx, fMagField, pVecAt) ; }
+ if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTPCx, fMagField, pVecAt) ; }
+ else       { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTPCx, fMagField, pVecAt) ; }
  pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
  nClus = fTrack->GetTPCclusters(idXt) ;
  fNFound = fTrack->GetTPCNclsF() ;  // was 160
@@ -277,8 +267,8 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  fFlowTrack->SetChi2TPC((Float_t)(fTrack->GetTPCchi2())) ;     
  fFlowTrack->SetPatTPC(pAt) ;                                  
  // -
- if(fNewAli) { boh = fTrack->GetPxPyPzAt(Flow::fITSx, fMagField, pVecAt) ; }
- else       { boh = fTrack->GetInnerParam()->GetPxPyPzAt(Flow::fITSx, fMagField, pVecAt) ; }
+ if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgITSx, fMagField, pVecAt) ; }
+ else       { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgITSx, fMagField, pVecAt) ; }
  pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
  nClus = fTrack->GetITSclusters(idX) ;
  fNFound = 6 ;
@@ -288,8 +278,8 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  fFlowTrack->SetChi2ITS((Float_t)(fTrack->GetITSchi2())) ;     
  fFlowTrack->SetPatITS(pAt) ;                                  
  // -
- if(fNewAli) { boh = fTrack->GetPxPyPzAt(Flow::fTRDx, fMagField, pVecAt) ; } 
- else       { boh = fTrack->GetInnerParam()->GetPxPyPzAt(Flow::fTRDx, fMagField, pVecAt) ; } 
+ if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTRDx, fMagField, pVecAt) ; } 
+ else       { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTRDx, fMagField, pVecAt) ; } 
  pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
  fNFound = fTrack->GetTRDncls() ;  // was 130
  nClus = fTrack->GetTRDclusters(idxr) ;
@@ -299,8 +289,8 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  fFlowTrack->SetChi2TRD((Float_t)fTrack->GetTRDchi2()) ;       
  fFlowTrack->SetPatTRD(pAt) ;                                  
  // -
- if(fNewAli) { boh = fTrack->GetPxPyPzAt(Flow::fTOFx, fMagField, pVecAt) ; }
- else       { boh = fTrack->GetInnerParam()->GetPxPyPzAt(Flow::fTOFx, fMagField, pVecAt) ; }
+ if(fNewAli) { boh = fTrack->GetPxPyPzAt(AliFlowConstants::fgTOFx, fMagField, pVecAt) ; }
+ else       { boh = fTrack->GetInnerParam()->GetPxPyPzAt(AliFlowConstants::fgTOFx, fMagField, pVecAt) ; }
  pAt = (Float_t)Norm(pVecAt) ; if(!pAt) { pAt = (Float_t)Norm(gD) ; }
  fNFound = 0 ; if(fTrack->GetTOFCalChannel() > 0) { fNFound = 1 ; }
  nClus = fTrack->GetTOFcluster() ;
@@ -315,26 +305,26 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  // -
  fTrack->GetInnerXYZ(rIn) ;                                    
  fFlowTrack->SetZFirstPoint(rIn[2]) ; 
- //fTrack->GetXYZAt(Flow::fTPCx,fMagField,rOut) ;              
+ //fTrack->GetXYZAt(AliFlowConstants::fgTPCx,fMagField,rOut) ;         
  fTrack->GetOuterXYZ(rOut) ;                                   
  fFlowTrack->SetZLastPoint(rOut[2]) ; 
  
  // ESD-P.Id. = 5-vector of Best detectors probabilities for [e , mu , pi , K , p] 
  Double_t trkPid[5] ; fTrack->GetESDpid(trkPid) ;              
- Double_t trkPid6[Flow::nPid] ; 
+ Double_t trkPid6[AliFlowConstants::kPid] ; 
  for(Int_t bb=0;bb<5;bb++) { trkPid6[bb] = trkPid[bb] ; } 
  trkPid6[5] = 0. ;                                             // *!* implement P.Id. for Deuterim
 
  // Bayesian P.Id. method (weighted probabilities for [e , mu , pi , K , p , d])
- Double_t Bsum = 0 ; 
- Double_t bayePid[Flow::nPid] ;    // normalized P.id
- Double_t storedPid[Flow::nPid] ;  // stored P.id
- for(Int_t nB=0;nB<Flow::nPid;nB++)  { Bsum += trkPid6[nB]*Flow::fBayesian[nB] ; }
- if(Bsum)
+ Double_t bsum = 0 ; 
+ Double_t bayePid[AliFlowConstants::kPid] ;    // normalized P.id
+ Double_t storedPid[AliFlowConstants::kPid] ;  // stored P.id
+ for(Int_t nB=0;nB<AliFlowConstants::kPid;nB++)  { bsum += trkPid6[nB]*AliFlowConstants::fgBayesian[nB] ; }
+ if(bsum)
  {
-  for(Int_t nB=0;nB<Flow::nPid;nB++) 
+  for(Int_t nB=0;nB<AliFlowConstants::kPid;nB++) 
   { 
-   bayePid[nB] = trkPid6[nB]*Flow::fBayesian[nB] / Bsum ; 
+   bayePid[nB] = trkPid6[nB]*AliFlowConstants::fgBayesian[nB] / bsum ; 
    storedPid[nB] = trkPid6[nB] ; 
   }
  }
@@ -348,17 +338,17 @@ AliFlowTrack* AliFlowMaker::FillFlowTrack(AliESDtrack* fTrack)
  fFlowTrack->SetDeuteriumAntiDeuteriumProb(storedPid[5]);      // *!* implement P.Id. for Deuterim
 
  // P.id. label given via the weighted prob.
- const Int_t code[]   =  {11,13,211,321,2212,10010020} ;
+ const Int_t kCode[]   =  {11,13,211,321,2212,10010020} ;
  Int_t kkk = 2 ;                       // if No id. -> then is a Pi
- Float_t pid_max = bayePid[2] ;        // (if all equal, Pi probability get's the advantage to be the first)
+ Float_t pidMax = bayePid[2] ;         // (if all equal, Pi probability get's the advantage to be the first)
  for(Int_t iii=0; iii<5; iii++) 
  {
-  if(bayePid[iii]>pid_max) { kkk = iii ; pid_max = bayePid[iii] ; }  // !!! Bayesian as well !!!
+  if(bayePid[iii]>pidMax) { kkk = iii ; pidMax = bayePid[iii] ; }  // !!! Bayesian as well !!!
  }
  fBayesianAll[kkk]++ ; fSumAll++ ;     // goes on filling the vector of observed abundance 
  //-
- Int_t pdg_code = trk_sign*code[kkk] ;
- fFlowTrack->SetMostLikelihoodPID(pdg_code);
+ Int_t pdgCode = trkSign*kCode[kkk] ;
+ fFlowTrack->SetMostLikelihoodPID(pdgCode);
  
  return fFlowTrack ; 
 }
@@ -371,14 +361,14 @@ AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
  fFlowV0 = new AliFlowV0(name.Data()) ;
  //cout << " -v0- " << name.Data() << endl ;
 
- Double_t Pxyz[3] ;            // reconstructed momentum of the V0
- fV0->GetPxPyPz(Pxyz[0],Pxyz[1],Pxyz[2]) ;
+ Double_t pxyz[3] ;            // reconstructed momentum of the V0
+ fV0->GetPxPyPz(pxyz[0],pxyz[1],pxyz[2]) ;
 
- Float_t phi = (Float_t)Phi(Pxyz) ; if(phi<0) { phi += 2*TMath::Pi() ; }
+ Float_t phi = (Float_t)Phi(pxyz) ; if(phi<0) { phi += 2*TMath::Pi() ; }
  fFlowV0->SetPhi(phi) ;                
- Float_t pt = (Float_t)Pt(Pxyz) ; 
+ Float_t pt = (Float_t)Pt(pxyz) ; 
  fFlowV0->SetPt(pt) ;          
- Float_t eta = (Float_t)Eta(Pxyz) ; 
+ Float_t eta = (Float_t)Eta(pxyz) ; 
  fFlowV0->SetEta(eta) ;        
 
  Double_t xyz[3] ;             // reconstructed position of the V0 
@@ -396,8 +386,8 @@ AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
  fFlowV0->SetSigma(1.); 
 
  // P.id. 
- Int_t pdg_code = fV0->GetPdgCode() ;
- fFlowV0->SetMostLikelihoodPID(pdg_code);      
+ Int_t pdgCode = fV0->GetPdgCode() ;
+ fFlowV0->SetMostLikelihoodPID(pdgCode);       
 
  // mass 
  fFlowV0->SetVmass((Float_t)fV0->GetEffMass()) ; 
@@ -411,24 +401,24 @@ AliFlowV0* AliFlowMaker::FillFlowV0(AliESDv0* fV0)
  return fFlowV0 ;
 }
 //-----------------------------------------------------------------------
-Bool_t AliFlowMaker::CheckTrack(AliESDtrack* fTrack)
+Bool_t AliFlowMaker::CheckTrack(AliESDtrack* fTrack) const
 {
- // applies track cuts (E , nHits , label)
+ // applies track cuts (pE , nHits , label)
 
  Int_t idXt[180] ;  // used for Cluster Map ( see AliESDtrack::GetTPCclusters() )
  Int_t   nHits = fTrack->GetTPCclusters(idXt) ;
- Float_t     = fTrack->GetP() ;
+ Float_t pE    = fTrack->GetP() ;
  Int_t   label = fTrack->GetLabel() ;
  
  if(fNHits && (nHits<=fNHits))                                                  { return kFALSE ; }
- if((fElow < fEup) && ((E<fElow) || (E>fEup)))                          { return kFALSE ; }
+ if((fElow < fEup) && ((pE<fElow) || (pE>fEup)))                        { return kFALSE ; }
  if((fLabel[0] < fLabel[1]) && ((label<fLabel[0]) || (label>fLabel[1]))) { return kFALSE ; }
  //if(fPrimary && ...)                                                          { return kFALSE ; }
 
  return kTRUE ;
 }
 //-----------------------------------------------------------------------
-Bool_t AliFlowMaker::CheckV0(AliESDv0* fV0)
+Bool_t AliFlowMaker::CheckV0(AliESDv0* fV0) const
 {
  // applies v0 cuts (dummy)
  
@@ -437,7 +427,7 @@ Bool_t AliFlowMaker::CheckV0(AliESDv0* fV0)
  return kTRUE ;
 }
 //-----------------------------------------------------------------------
-Bool_t AliFlowMaker::CheckEvent(AliESD* fESD)
+Bool_t AliFlowMaker::CheckEvent(AliESD* fESD) const
 {
  // applies event cuts (dummy)
  
index b1487e40f1b43bdc8a1a25cc52c6f6a5c3177628..4177c4cba599c1c2f1c0476cc00f1577492e060c 100644 (file)
@@ -7,6 +7,8 @@
 //////////////////////////////////////////////////////////////////////
 //
 // Description: parser class from AliESD to AliFlowEvent . 
+//  nothing else to say, but those 3 lines need to be filled somehow,
+//  I hope now is ok!
 //
 //////////////////////////////////////////////////////////////////////
 
@@ -40,23 +42,23 @@ class AliFlowMaker  {
     Double_t      Eta(Double_t nu[3]) ;                    // eta of a non-vector 3 array       
 
   // Cut METHODS
-    Bool_t         CheckTrack(AliESDtrack* fTrack) ;       // checks track (applies track cuts)
-    Bool_t         CheckV0(AliESDv0* fV0) ;                // checks v0 (dummy)
-    Bool_t         CheckEvent(AliESD* fESD) ;              // checks event (dummy)
+    Bool_t         CheckTrack(AliESDtrack* fTrack) const ;  // checks track (applies track cuts)
+    Bool_t         CheckV0(AliESDv0* fV0) const ;          // checks v0 (dummy)
+    Bool_t         CheckEvent(AliESD* fESD) const ;        // checks event (dummy)
     void          PrintCutList() ;                         // prints the list of cuts
     void          SetNHitsCut(Int_t nHits)                 { fNHits = nHits ; }                        // exclude tracks with less than .. TPC hits 
     void          SetECut(Float_t eLow, Float_t eUp)       { fElow = eLow ; fEup = eUp ; }             // exclude tracks below and above .. GeV 
     void          SetLabelCut(Int_t labLo, Int_t labHi)    { fLabel[0] = labLo ; fLabel[1] = labHi ; } // exclude tracks outside label interval
 
   // Get METHODS
-    Int_t          GetNgoodTracks()                        { return fGoodTracks ; }      
-    Int_t          GetNgoodV0s()                           { return fGoodV0s ; }         
-    Int_t          GetNgoodTracksEta()                     { return fGoodTracksEta ; } 
-    Int_t          GetNposiTracks()                        { return fPosiTracks ; }    
-    Int_t          GetNnegaTracks()                        { return fNegaTracks ; }    
-    Int_t          GetNunconstrained()                     { return fUnconstrained ; } 
-    Int_t          GetBayesian(Int_t i = 2)                { return fBayesianAll[i] ; }
-    Float_t        GetBayesianNorm(Int_t i = 2)            { return (Float_t)fBayesianAll[i] / (Float_t)fSumAll ; }
+    Int_t          GetNgoodTracks() const                  { return fGoodTracks ; }      
+    Int_t          GetNgoodV0s() const                     { return fGoodV0s ; }         
+    Int_t          GetNgoodTracksEta() const               { return fGoodTracksEta ; } 
+    Int_t          GetNposiTracks() const                  { return fPosiTracks ; }    
+    Int_t          GetNnegaTracks() const                  { return fNegaTracks ; }    
+    Int_t          GetNunconstrained()  const              { return fUnconstrained ; } 
+    Int_t          GetBayesian(Int_t i = 2) const          { return fBayesianAll[i] ; }
+    Float_t        GetBayesianNorm(Int_t i = 2) const      { return (Float_t)fBayesianAll[i] / (Float_t)fSumAll ; }
 
  protected:
  
@@ -87,6 +89,9 @@ class AliFlowMaker  {
 
  private:
 
+   //AliFlowMaker(const AliFlowMaker &flowMak)                     { flowMak.fCounter ; } // Copy Constructor (dummy)
+   //AliFlowMaker &operator=(const AliFlowMaker &flowMak)   { return *this ; }   // Assignment Operator
+
   // ESDs
     AliESD*          fESD;                                 //! "ESD" branch in fChain
     AliESDtrack*     fTrack;                               //! "ESD track" 
index 76f904e51e14207d3073e7a9243ed287fb3fc15f..f56c97a264c4ce0f131edd12ac547861fb11fcf1 100644 (file)
 //
 
 #include "AliFlowSelection.h"
+#include "AliFlowEvent.h"
+#include "AliFlowTrack.h"
+#include "AliFlowV0.h"
 #include "AliFlowConstants.h"
+
 #include <iostream>
+#include <stdlib.h>
+#include <string.h>
 using namespace std; //required for resolving the 'cout' symbol
 
 // - 1st selection (both harmonic) is Disabled ! - the 2 following are the same (basic cuts, no P.id)
-Float_t  AliFlowSelection::fEtaTpcCuts[2][Flow::nHars][Flow::nSels] = {{{1.0,0.0},{1.0,0.0}},{{0.0,1.1},{0.0,1.1}}} ;
-Float_t  AliFlowSelection::fPtTpcCuts[2][Flow::nHars][Flow::nSels]  = {{{1.0,0.1},{1.0,0.1}},{{0.0,10.0},{0.0,10.0}}} ;
-Float_t  AliFlowSelection::fDcaGlobalCuts[2]    = { 0. , 1. } ;
-Char_t   AliFlowSelection::fPid[10]              = { '\0' } ;
-Bool_t   AliFlowSelection::fConstrainable        = kTRUE ;
-Int_t    AliFlowSelection::fTPChits[Flow::nSels] = { 0 , 1 } ;
+Float_t  AliFlowSelection::fgEtaTpcCuts[2][AliFlowConstants::kHars][AliFlowConstants::kSels] = {{{1.0,0.0},{1.0,0.0}},{{0.0,1.1},{0.0,1.1}}} ;
+Float_t  AliFlowSelection::fgPtTpcCuts[2][AliFlowConstants::kHars][AliFlowConstants::kSels]  = {{{1.0,0.1},{1.0,0.1}},{{0.0,10.0},{0.0,10.0}}} ;
+Float_t  AliFlowSelection::fgDcaGlobalCuts[2]    = { 0. , 1. } ;
+Char_t   AliFlowSelection::fgPid[10]              = { '\0' } ;
+Bool_t   AliFlowSelection::fgConstrainable        = kTRUE ;
+Int_t    AliFlowSelection::fgTPChits[AliFlowConstants::kSels] = { 0 , 1 } ;
 
 ClassImp(AliFlowSelection)
 //-----------------------------------------------------------------------
@@ -96,7 +102,7 @@ AliFlowSelection::AliFlowSelection()
  fV0Mass[0]           = 1 ;
  fV0Mass[1]           = 0 ;
  // -
- fPtBinsPart          = Flow::nPtBinsPart ;  
+ fPtBinsPart          = AliFlowConstants::kPtBinsPart ;  
  // -                  
  fHarmonic  = -1 ;   // harmonic
  fSelection = -1 ;   // selection
@@ -108,7 +114,7 @@ AliFlowSelection::~AliFlowSelection()
  // default destructor (dummy)
 }
 //-----------------------------------------------------------------------
-Bool_t AliFlowSelection::Select(AliFlowEvent* pFlowEvent) 
+Bool_t AliFlowSelection::Select(AliFlowEvent* pFlowEvent) const 
 {
  // Returns kTRUE if the event is selected. 
 
@@ -119,7 +125,7 @@ Bool_t AliFlowSelection::Select(AliFlowEvent* pFlowEvent)
  return kTRUE ;
 }
 //-----------------------------------------------------------------------
-Bool_t AliFlowSelection::Select(AliFlowTrack* pFlowTrack)
+Bool_t AliFlowSelection::Select(AliFlowTrack* pFlowTrack) const 
 {
  // Selects particles for event plane determination.
  // Returns kTRUE if the track is selected.
@@ -128,7 +134,7 @@ Bool_t AliFlowSelection::Select(AliFlowTrack* pFlowTrack)
  return kTRUE ;
 }
 //-----------------------------------------------------------------------
-Bool_t AliFlowSelection::Select(AliFlowV0* pFlowV0) 
+Bool_t AliFlowSelection::Select(AliFlowV0* pFlowV0) const  
 {
  // Returns kTRUE if the v0 is selected. (dummy) 
 
@@ -136,7 +142,7 @@ Bool_t AliFlowSelection::Select(AliFlowV0* pFlowV0)
  return kTRUE ;
 }
 //-----------------------------------------------------------------------
-Bool_t AliFlowSelection::SelectPart(AliFlowTrack* pFlowTrack) 
+Bool_t AliFlowSelection::SelectPart(AliFlowTrack* pFlowTrack) const  
 {
  // Make track selection for Correlation Analysis & Vn (charged particles 
  // to correlate with the event plane).  
@@ -203,13 +209,13 @@ Bool_t AliFlowSelection::SelectPart(AliFlowTrack* pFlowTrack)
  if (fDcaGlobalPart[1] > fDcaGlobalPart[0] && (globdca < fDcaGlobalPart[0] || globdca > fDcaGlobalPart[1])) return kFALSE;
 
  // Rapidity
- float Y = pFlowTrack->Y();
- if (fYPart[1] > fYPart[0] && (Y < fYPart[0] || Y > fYPart[1])) return kFALSE;
+ float y = pFlowTrack->Y();
+ if (fYPart[1] > fYPart[0] && (y < fYPart[0] || y > fYPart[1])) return kFALSE;
 
  return kTRUE;
 }
 //-----------------------------------------------------------------------
-Bool_t AliFlowSelection::SelectPart(AliFlowV0* pFlowV0) 
+Bool_t AliFlowSelection::SelectPart(AliFlowV0* pFlowV0) const 
 {
  // Make v0 selection for Correlation Analysis & Vn (neutral particles 
  // to correlate with the event plane).  
@@ -276,13 +282,13 @@ Bool_t AliFlowSelection::SelectPart(AliFlowV0* pFlowV0)
  }
 
  // Rapidity
- float Y = pFlowV0->Y();
- if (fV0Y[1] > fV0Y[0] && (Y < fV0Y[0] || Y > fV0Y[1])) return kFALSE;
+ float y = pFlowV0->Y();
+ if (fV0Y[1] > fV0Y[0] && (y < fV0Y[0] || y > fV0Y[1])) return kFALSE;
 
  return kTRUE;
 }
 //-----------------------------------------------------------------------
-Bool_t  AliFlowSelection::SelectV0Part(AliFlowV0* pFlowV0)
+Bool_t  AliFlowSelection::SelectV0Part(AliFlowV0* pFlowV0) const 
 { 
  // selects v0s in the invariant Mass window
  
@@ -294,9 +300,10 @@ Bool_t  AliFlowSelection::SelectV0Part(AliFlowV0* pFlowV0)
  return kTRUE;
 }
 //-----------------------------------------------------------------------
-Bool_t  AliFlowSelection::SelectV0Side(AliFlowV0* pFlowV0)
+Bool_t  AliFlowSelection::SelectV0Side(AliFlowV0* pFlowV0) const 
 { 
  // selects v0s in the sidebands of the Mass window
  float mass = pFlowV0->Mass() ;
  if(fV0Mass[1]>fV0Mass[0])
  { 
@@ -307,18 +314,20 @@ Bool_t  AliFlowSelection::SelectV0Side(AliFlowV0* pFlowV0)
  return kTRUE;
 }
 //-----------------------------------------------------------------------
-Bool_t  AliFlowSelection::SelectV0sxSide(AliFlowV0* pFlowV0)
+Bool_t  AliFlowSelection::SelectV0sxSide(AliFlowV0* pFlowV0) const 
 { 
  // selects v0s in the left hand sideband
  float mass = pFlowV0->Mass() ;
  float massMin = fV0Mass[0]-fV0SideBand ;
  if((mass >= massMin) && (mass < fV0Mass[0]))  { return kTRUE ; }
  else                                          { return kFALSE ; }
 }
 //-----------------------------------------------------------------------
-Bool_t  AliFlowSelection::SelectV0dxSide(AliFlowV0* pFlowV0)
+Bool_t  AliFlowSelection::SelectV0dxSide(AliFlowV0* pFlowV0) const 
 { 
  // selects v0s in the right hand sideband
  float mass = pFlowV0->Mass() ;
  float massMax = fV0Mass[1]+fV0SideBand ;
  if((mass > fV0Mass[1]) && (mass <= massMax))  { return kTRUE ; }
@@ -404,9 +413,9 @@ void AliFlowSelection::PrintSelectionList() const
   cout << "#######################################################" << endl;
   cout << "# Event centrality: " << endl ; 
   float lowC, hiC ;
-  if(fCent==0)      { lowC=0 ; hiC=Flow::fCentNorm[0] * Flow::fMaxMult ; }
-  else if(fCent>8)  { lowC=Flow::fCentNorm[8] * Flow::fMaxMult ; hiC=99999 ; }
-  else              { lowC=Flow::fCentNorm[fCent-1] * Flow::fMaxMult ; hiC=Flow::fCentNorm[fCent] * Flow::fMaxMult ; }
+  if(fCent==0)      { lowC=0 ; hiC=AliFlowConstants::fgCentNorm[0] * AliFlowConstants::fgMaxMult ; }
+  else if(fCent>8)  { lowC=AliFlowConstants::fgCentNorm[8] * AliFlowConstants::fgMaxMult ; hiC=99999 ; }
+  else              { lowC=AliFlowConstants::fgCentNorm[fCent-1] * AliFlowConstants::fgMaxMult ; hiC=AliFlowConstants::fgCentNorm[fCent] * AliFlowConstants::fgMaxMult ; }
   cout << "#  - Centrality Class = " << fCent << " ( " << (int)lowC << " < mult < " << (int)hiC << " ) . " << endl ; 
  }
  else      
@@ -417,15 +426,15 @@ void AliFlowSelection::PrintSelectionList() const
 
  cout << "#######################################################" << endl;
  cout << "# Tracks used for the event plane: " << endl ; 
- cout << "#  - Selection[0]    (for all " << Flow::nHars << " Harmonics) :  " << endl ; 
+ cout << "#  - Selection[0]    (for all " << AliFlowConstants::kHars << " Harmonics) :  " << endl ; 
  cout << "#   NO CUTS " << endl ; 
- cout << "#  - Selection[1+]   (for all " << Flow::nHars << " Harmonics) : " << endl ; 
+ cout << "#  - Selection[1+]   (for all " << AliFlowConstants::kHars << " Harmonics) : " << endl ; 
  if(Pid()[0] != '\0')                  { cout << "#   Particle ID =  " << Pid() << endl ; } 
  if(ConstrainCut())                    { cout << "#   Constrainable Tracks " << endl ; }
  if(DcaGlobalCutHi()>DcaGlobalCutLo())         { cout << "#   Global Dca Tpc cuts =  " << DcaGlobalCutLo() << " , " << DcaGlobalCutHi() << endl ; }
- for (int k = 1; k < Flow::nSels; k++) 
+ for (int k = 1; k < AliFlowConstants::kSels; k++) 
  {
-  for (int j = 0; j < Flow::nHars ; j++) 
+  for (int j = 0; j < AliFlowConstants::kHars ; j++) 
   {
    cout << "#  - Selection[" << k << "] , Harmonic[" << j+1 << "] :" << endl ;
    if(NhitsCut(k))                     { cout << "#   Minimum TPC hits =  " << NhitsCut(k) << endl ; }
@@ -438,7 +447,9 @@ void AliFlowSelection::PrintSelectionList() const
 //-----------------------------------------------------------------------
 void AliFlowSelection::SetHarmonic(const Int_t& harN) 
 {
- if (harN < 0 || harN >= Flow::nHars) 
+ // sets the Harmonic #
+
+ if (harN < 0 || harN >= AliFlowConstants::kHars) 
  {
   cout << "### Harmonic " << harN << " not valid" << endl;
   fHarmonic = 0;
@@ -448,7 +459,9 @@ void AliFlowSelection::SetHarmonic(const Int_t& harN)
 //-----------------------------------------------------------------------
 void AliFlowSelection::SetSelection(const Int_t& selN) 
 {
- if (selN < 0 || selN >= Flow::nSels) 
+ // sets the Selection #
+
+ if (selN < 0 || selN >= AliFlowConstants::kSels) 
  {
   cout << "### Selection " << selN << " not valid" << endl;
   fSelection = 0;
@@ -458,7 +471,9 @@ void AliFlowSelection::SetSelection(const Int_t& selN)
 //-----------------------------------------------------------------------
 void AliFlowSelection::SetSubevent(const Int_t& subN) 
 {
- if (subN < -1 || subN > Flow::nSubs) 
+ // sets the Sub-Event # (-1 for the full-event)
+
+ if (subN < -1 || subN > AliFlowConstants::kSubs) 
  {
   cout << "### Subevent " << subN << " not valid" << endl;
   fSubevent = -1;
@@ -466,42 +481,10 @@ void AliFlowSelection::SetSubevent(const Int_t& subN)
  else { fSubevent = subN; } 
 }
 //-----------------------------------------------------------------------
-void AliFlowSelection::SetEtaCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN) 
-{ 
- fEtaTpcCuts[0][harN][selN] = lo ; 
- fEtaTpcCuts[1][harN][selN] = hi ; 
-}
-//-----------------------------------------------------------------------
-void AliFlowSelection::SetPtCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN)  
-{ 
- fPtTpcCuts[0][harN][selN] = lo  ; 
- fPtTpcCuts[1][harN][selN] = hi ; 
-}
-//-----------------------------------------------------------------------
-void AliFlowSelection::SetDcaGlobalCut(Float_t lo, Float_t hi)      
-{ 
- fDcaGlobalCuts[0] = lo ; 
- fDcaGlobalCuts[1] = hi ; 
-}
-//-----------------------------------------------------------------------
-void AliFlowSelection::SetPidCut(const Char_t* pid)           
-{ 
- strncpy(fPid, pid, 9) ; 
- fPid[9] = '\0' ; 
-}
-//-----------------------------------------------------------------------
-void AliFlowSelection::SetConstrainCut(Bool_t tf) 
-{ 
- fConstrainable = tf ; 
-}
-//-----------------------------------------------------------------------
-void AliFlowSelection::SetNhitsCut(Int_t hits,Int_t selN)
-{ 
- fTPChits[selN] = hits; 
-}
-//-----------------------------------------------------------------------
-Float_t AliFlowSelection::PtMaxPart() const                           
-{ 
+Float_t AliFlowSelection::PtMaxPart() const                   
+{
+ // Returns the upper pT cut for particle used in correlation analysis
  if(fPtPart[1]>fPtPart[0]) { return fPtPart[1] ; } 
  else { return 0. ; } 
 }
index 1f728dce6d120b3dcffa96a84f692c9b7d4afa43..f0dd95182c0ada807011d0ec1181373ef5b93aa1 100644 (file)
@@ -6,7 +6,9 @@
 //
 //////////////////////////////////////////////////////////////////////
 //
-// Description: class for selections in flow study, adapted from STAR 
+// Description: class for selections in flow study, adapted from STAR
+//  it is applied to AliFlowEvent during the analysis loop . 
+//                             ... I really hate the code checker !!!
 // Original Authors:                Raimond Snellings & Art Poskanzer
 //
 //////////////////////////////////////////////////////////////////////
 #ifndef AliFlowSelection_h
 #define AliFlowSelection_h
 
-#include <iostream>
-#include <stdlib.h>
-#include <string.h>
-
 #include "TObject.h"
-#include "TVector.h"
 #include "TMath.h"
-#include <TROOT.h>
 
-#include "AliFlowSelection.h"
-#include "AliFlowEvent.h"
-#include "AliFlowTrack.h"
-#include "AliFlowV0.h"
 #include "AliFlowConstants.h"
 
 class AliFlowTrack ;
+class AliFlowV0 ;
 class AliFlowEvent ;
-class Flow ;
+class AliFlowConstants ;
 
 class AliFlowSelection : public TObject {
 
@@ -42,15 +35,15 @@ class AliFlowSelection : public TObject {
   virtual ~AliFlowSelection();
 
  // Selection Methods for ... 
-  Bool_t  Select(AliFlowEvent*);                      // (dummy)
-  Bool_t  Select(AliFlowTrack*);                      // selection for R.P.[nSel][nHar]
-  Bool_t  Select(AliFlowV0*);                         // (dummy) 
-  Bool_t  SelectPart(AliFlowTrack*);                  // track selection for Correlation Analysis
-  Bool_t  SelectPart(AliFlowV0*);                     // v0 selection for Correlation Analysis (mass window + sidebands)
-  Bool_t  SelectV0Part(AliFlowV0*);                           // v0 mass window for Correlation Analysis 
-  Bool_t  SelectV0Side(AliFlowV0*);                           // v0 sidebands for Correlation Analysis 
-  Bool_t  SelectV0sxSide(AliFlowV0*);                 // selects v0s in the left hand sideband
-  Bool_t  SelectV0dxSide(AliFlowV0*);                 // selects v0s in the right hand sideband
+  Bool_t  Select(AliFlowEvent* pFlowEvent) const ;     // (dummy)
+  Bool_t  Select(AliFlowTrack* pFlowTrack) const ;     // selection for R.P.[nSel][nHar]
+  Bool_t  Select(AliFlowV0* pFlowV0) const ;           // (dummy) 
+  Bool_t  SelectPart(AliFlowTrack* pFlowTrack) const ; // track selection for Correlation Analysis
+  Bool_t  SelectPart(AliFlowV0* pFlowV0) const ;       // v0 selection for Correlation Analysis (mass window + sidebands)
+  Bool_t  SelectV0Part(AliFlowV0* pFlowV0) const ;     // v0 mass window for Correlation Analysis 
+  Bool_t  SelectV0Side(AliFlowV0* pFlowV0) const ;     // v0 sidebands for Correlation Analysis 
+  Bool_t  SelectV0sxSide(AliFlowV0* pFlowV0) const ;   // selects v0s in the left hand sideband
+  Bool_t  SelectV0dxSide(AliFlowV0* pFlowV0) const ;   // selects v0s in the right hand sideband
 
  // Gets (Harmonic, Selection, Sub-event)
   Int_t   Sel() const                                 { return fSelection; }                  // Returns the Harmonic 
@@ -58,15 +51,15 @@ class AliFlowSelection : public TObject {
   Int_t   Sub() const                                 { return fSubevent; }                   // Returns the Sub-Event
 
  // Gets (R.P. cuts) and CutList
-  Float_t EtaCutLo(Int_t harN, Int_t selN) const       { return fEtaTpcCuts[0][harN][selN] ; } // Returns lower eta cut for R.P.[harN][selN] calculation (absolute values)
-  Float_t EtaCutHi(Int_t harN, Int_t selN) const       { return fEtaTpcCuts[1][harN][selN] ; } // Returns upper eta cut for R.P.[harN][selN] calculation (absolute values)
-  Float_t PtCutLo(Int_t harN, Int_t selN) const        { return fPtTpcCuts[0][harN][selN] ; }  // Returns lower pT cut for R.P.[harN][selN] calculation 
-  Float_t PtCutHi(Int_t harN, Int_t selN) const        { return fPtTpcCuts[1][harN][selN] ; }  // Returns upper pT cut for R.P.[harN][selN] calculation
-  Float_t DcaGlobalCutLo() const                      { return fDcaGlobalCuts[0] ; }          // Returns lower DCA cut for R.P. calculation
-  Float_t DcaGlobalCutHi() const                      { return fDcaGlobalCuts[1] ; }          // Returns upper DCA cut for R.P. calculation
-  Bool_t  ConstrainCut() const                        { return fConstrainable ; }             // Returns kTRUE/kFalse if the cut over un-constrainable tracks is enabled
-  Int_t   NhitsCut(Int_t selN) const                  { return fTPChits[selN] ; }             // Returns the minimum number of TPC hits for R.P.[selN] calculation
-  Char_t* Pid() const                                 { return fPid; }                        // Returns particle specie used in R.P. calculation
+  Float_t EtaCutLo(Int_t harN, Int_t selN) const       { return fgEtaTpcCuts[0][harN][selN] ; } // Returns lower eta cut for R.P.[harN][selN] calculation (absolute values)
+  Float_t EtaCutHi(Int_t harN, Int_t selN) const       { return fgEtaTpcCuts[1][harN][selN] ; } // Returns upper eta cut for R.P.[harN][selN] calculation (absolute values)
+  Float_t PtCutLo(Int_t harN, Int_t selN) const        { return fgPtTpcCuts[0][harN][selN] ; }  // Returns lower pT cut for R.P.[harN][selN] calculation 
+  Float_t PtCutHi(Int_t harN, Int_t selN) const        { return fgPtTpcCuts[1][harN][selN] ; }  // Returns upper pT cut for R.P.[harN][selN] calculation
+  Float_t DcaGlobalCutLo() const                      { return fgDcaGlobalCuts[0] ; }         // Returns lower DCA cut for R.P. calculation
+  Float_t DcaGlobalCutHi() const                      { return fgDcaGlobalCuts[1] ; }         // Returns upper DCA cut for R.P. calculation
+  Bool_t  ConstrainCut() const                        { return fgConstrainable ; }            // Returns kTRUE/kFalse if the cut over un-constrainable tracks is enabled
+  Int_t   NhitsCut(Int_t selN) const                  { return fgTPChits[selN] ; }            // Returns the minimum number of TPC hits for R.P.[selN] calculation
+  Char_t* Pid() const                                 { return fgPid; }                       // Returns particle specie used in R.P. calculation
 
  // Gets (Event cuts)
   Int_t   CentralityCut() const                               { return fCent ; }                      // Returns Event Centrality class
@@ -83,17 +76,17 @@ class AliFlowSelection : public TObject {
   void    PrintV0List() const ;                                                                       // Prints the v0s cut-list (for correlation analysis)
 
  // Harmonic & Selection set (R.P.)
-  void    SetHarmonic(const Int_t&);                                                          // Sets the Harmonic
-  void    SetSelection(const Int_t&);                                                         // Sets the Selection
-  void    SetSubevent(const Int_t&);                                                          // Sets the Sub-Event
+  void    SetHarmonic(const Int_t& harN);                                                             // Sets the Harmonic
+  void    SetSelection(const Int_t& selN);                                                            // Sets the Selection
+  void    SetSubevent(const Int_t& subN);                                                             // Sets the Sub-Event
   
  // Cuts set (Reaction Plane)
-  static void  SetPidCut(const Char_t* pid);                                                  // Sets the particle specie used in R.P. calculation
-  static void  SetEtaCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN);                     // Sets |eta| cut for R.P.[harN][selN] calculation
-  static void  SetPtCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN);                      // Sets pT cut for R.P.[harN][selN] calculation
-  static void  SetDcaGlobalCut(Float_t lo, Float_t hi);                                       // Sets DCA cut for R.P. calculation
-  static void  SetConstrainCut(Bool_t tf = kTRUE) ;                                           // Sets the cut over un-constrainable tracks
-  static void  SetNhitsCut(Int_t hits, Int_t selN) ;                                          // Sets the minimum number of TPC hits for R.P.[selN] calculation
+  static void SetEtaCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN) { fgEtaTpcCuts[0][harN][selN] = lo ; fgEtaTpcCuts[1][harN][selN] = hi ; } // Sets the particle specie used in R.P. calculation
+  static void SetPtCut(Float_t lo, Float_t hi, Int_t harN, Int_t selN)  { fgPtTpcCuts[0][harN][selN] = lo  ; fgPtTpcCuts[1][harN][selN] = hi ; }  // Sets |eta| cut for R.P.[harN][selN] calculation
+  static void SetDcaGlobalCut(Float_t lo, Float_t hi)                  { fgDcaGlobalCuts[0] = lo ; fgDcaGlobalCuts[1] = hi ; }                   // Sets pT cut for R.P.[harN][selN] calculation
+  static void SetPidCut(const Char_t* pid)                             { strncpy(fgPid, pid, 9) ; fgPid[9] = '\0' ; }                            // Sets DCA cut for R.P. calculation
+  static void SetConstrainCut(Bool_t tf = kTRUE)                       { fgConstrainable = tf ; }                                                // Sets the cut over un-constrainable tracks
+  static void SetNhitsCut(Int_t hits,Int_t selN)                       { fgTPChits[selN] = hits; }                                               // Sets the minimum number of TPC hits for R.P.[selN] calculation
 
  // Sets (Event cuts)
   void    SetCentralityCut(Int_t cent)                { fCent = cent ; }                      // Sets Event Centrality class
@@ -174,12 +167,12 @@ class AliFlowSelection : public TObject {
   Bool_t  fConstrainablePart;                                  // constrainability for parts. wrt plane 
 
  // Cuts for Tracks used in determining the Raction Plane (in STAR this selection was done inside the AliFlowEvent class)
-  static Float_t  fEtaTpcCuts[2][Flow::nHars][Flow::nSels];    //! eta range (absolute values)
-  static Float_t  fPtTpcCuts[2][Flow::nHars][Flow::nSels];     //! pT range
-  static Float_t  fDcaGlobalCuts[2];                           //! DCA cuts
-  static Char_t   fPid[10];                                    //! h+, h-, pi-, pi+, pi, k+, k-, k, pr+, pr-, pr, e+, e-, e, d+, d-, d
-  static Int_t    fTPChits[Flow::nSels];                       //! minimum number of TPC hits
-  static Bool_t   fConstrainable;                              //! cut un-constrainable tracks 
+  static Float_t  fgEtaTpcCuts[2][AliFlowConstants::kHars][AliFlowConstants::kSels];   // eta range (absolute values)
+  static Float_t  fgPtTpcCuts[2][AliFlowConstants::kHars][AliFlowConstants::kSels];    // pT range
+  static Float_t  fgDcaGlobalCuts[2];                          // DCA cuts
+  static Char_t   fgPid[10];                                   // h+, h-, pi-, pi+, pi, k+, k-, k, pr+, pr-, pr, e+, e-, e, d+, d-, d
+  static Int_t    fgTPChits[AliFlowConstants::kSels];                  // minimum number of TPC hits
+  static Bool_t   fgConstrainable;                             // cut un-constrainable tracks 
 
 
   ClassDef(AliFlowSelection,1)                                 // macro for rootcint
index a745511d6c71a8a3222c1f22d7659ce7609a7c2b..3adf20d53abc45de90df4aaa8d28d1465636c60d 100644 (file)
@@ -52,7 +52,7 @@ AliFlowTrack::AliFlowTrack()
  fTrackLength = 0. ;
  fMostLikelihoodPID = 0 ;                    
  for(Int_t ii=0;ii<2;ii++)         { fDcaSigned[ii] = 0 ; }                          
- for(Int_t ii=0;ii<Flow::nPid;ii++) { fPidProb[ii] = 0. ; }
+ for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { fPidProb[ii] = 0. ; }
  for(Int_t ii=0;ii<4;ii++)
  {
   fFitPts[4]  = 0  ; fMaxPts[4]  = 0  ; 
@@ -196,9 +196,9 @@ void AliFlowTrack::PrintSelection()
  // Prints a short string of 0 & 1 to visualize the selections' flags
  // [har1][sel0],[har1][sel1],[har1][sel2],...,[har2][sel0],...
  
- for(int i=0;i<Flow::nHars;i++)
+ for(int i=0;i<AliFlowConstants::kHars;i++)
  {
-  for(int j=0;j<Flow::nSels;j++)
+  for(int j=0;j<AliFlowConstants::kSels;j++)
   {
    if(Select(i,j)) { cout << 1 ; }
    else           { cout << 0 ; }
@@ -212,9 +212,9 @@ void AliFlowTrack::ResetSelection()
  // Re-sets all the selection/sub-event flags to 0 
  // (track won't be used in any R.P. calculation)
 
- for(Int_t ii=0;ii<Flow::nHars;ii++)
+ for(Int_t ii=0;ii<AliFlowConstants::kHars;ii++)
  {
-  for(Int_t jj=0;jj<Flow::nSels;jj++)
+  for(Int_t jj=0;jj<AliFlowConstants::kSels;jj++)
   {
    fSelection[ii][jj] = kFALSE ; 
    fSubevent[ii][jj] = -1 ; 
@@ -247,17 +247,17 @@ const char* AliFlowTrack::Pid() const
  return p_id.Data() ; 
 }
 //////////////////////////////////////////////////////////////////////////////
-void AliFlowTrack::PidProbs(Float_t pidN[Flow::nPid]) const 
+void AliFlowTrack::PidProbs(Float_t pidN[AliFlowConstants::kPid]) const 
 { 
  // Returns the normalized probability for the given track to be [e,mu,pi,k,p,d] 
  // The detector response is weighted by the bayesian vector of particles 
- // abundances, stored in Flow::fBayesian[] .
+ // abundances, stored in AliFlowConstants::fgBayesian[] .
 
  Double_t sum = 0 ; 
- for(Int_t n=0;n<Flow::nPid;n++)  { sum += fPidProb[n] * Flow::fBayesian[n] ; }
+ for(Int_t n=0;n<AliFlowConstants::kPid;n++)  { sum += fPidProb[n] * AliFlowConstants::fgBayesian[n] ; }
  if(sum)
  {
-  for(Int_t n=0;n<Flow::nPid;n++) { pidN[n] = fPidProb[n] * Flow::fBayesian[n] / sum ; }
+  for(Int_t n=0;n<AliFlowConstants::kPid;n++) { pidN[n] = fPidProb[n] * AliFlowConstants::fgBayesian[n] / sum ; }
  }
  else { cout << " ERROR - Empty Bayesian Vector !!! " << endl ; }
 } 
@@ -266,7 +266,7 @@ Float_t  AliFlowTrack::PidProb(Int_t nn)    const
 {
  // Returns the normalized probability of the track to be [nn] (e,mu,pi,k,pi,d).
 
- Float_t pidN[Flow::nPid] ; 
+ Float_t pidN[AliFlowConstants::kPid] ; 
  PidProbs(pidN) ;
  return pidN[nn] ;
 }
@@ -276,19 +276,19 @@ TVector AliFlowTrack::PidProbs()                  const
  // Returns the normalized probability for the given track to be [e,mu,pi,k,p,d] 
  // as a TVector.
 
- TVector pidNvec(Flow::nPid) ;
- Float_t pidN[Flow::nPid] ; 
+ TVector pidNvec(AliFlowConstants::kPid) ;
+ Float_t pidN[AliFlowConstants::kPid] ; 
  PidProbs(pidN) ;
- for(Int_t n=0;n<Flow::nPid;n++)  { pidNvec[n] = pidN[n] ; }
+ for(Int_t n=0;n<AliFlowConstants::kPid;n++)  { pidNvec[n] = pidN[n] ; }
 
  return pidNvec ;
 }
 //////////////////////////////////////////////////////////////////////////////
-void AliFlowTrack::RawPidProbs(Float_t pidV[Flow::nPid]) const 
+void AliFlowTrack::RawPidProbs(Float_t pidV[AliFlowConstants::kPid]) const 
 { 
  // Returns the array of probabilities for the track to be [e,mu,pi,k,pi,d].
 
- for(Int_t ii=0;ii<Flow::nPid;ii++) { pidV[ii] = fPidProb[ii] ; }
+ for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++) { pidV[ii] = fPidProb[ii] ; }
 } 
 //////////////////////////////////////////////////////////////////////////////
 Float_t AliFlowTrack::MostLikelihoodProb()         const 
index 974ee829585e85d28915b3aa8db109d3f1234e16..63459ffd01dcfcf88a82611162de8ea871f08c54 100644 (file)
@@ -12,8 +12,8 @@
 //
 //////////////////////////////////////////////////////////////////////
 
-#ifndef AliFlowTrack_h
-#define AliFlowTrack_h
+#ifndef ALIFLOWTRACK_h
+#define ALIFLOWTRACK_h
 
 #include <string.h>
 #include <stdio.h>
@@ -28,8 +28,6 @@
 
 #include "AliFlowConstants.h"
 
-class Flow ;
-
 class AliFlowTrack : public TNamed {
 
 public:
@@ -73,10 +71,10 @@ public:
   Float_t       KaonPlusMinusProb()            const;
   Float_t       ProtonPbarProb()               const;
   Float_t       DeuteriumAntiDeuteriumProb()   const;
-  Float_t       PidProb(Int_t nn)              const;          // normalized detector response (using Flow::fBayesian[] )
+  Float_t       PidProb(Int_t nn)              const;          // normalized detector response (using AliFlowConstants::fgBayesian[] )
   TVector      PidProbs()                      const; 
-  void          PidProbs(Float_t pidN[Flow::nPid])    const; 
-  void          RawPidProbs(Float_t pidV[Flow::nPid]) const;   // raw ESD detector responses
+  void          PidProbs(Float_t pidN[AliFlowConstants::kPid])    const; 
+  void          RawPidProbs(Float_t pidV[AliFlowConstants::kPid]) const;       // raw ESD detector responses
  // Gets - Detector response
   Float_t       Chi2TPC()     const;
   Int_t         FitPtsTPC()   const;
@@ -175,7 +173,7 @@ private:
   Float_t  fPtGlobal;                          // transverse momentum of the unconstrained track 
   Int_t    fLabel ;                            // Label of the track (link: KineTree-ESD) 
  // -
-  Float_t  fPidProb[Flow::nPid] ;              // Array of probability to be   (e,mu,pi,k,p,d)
+  Float_t  fPidProb[AliFlowConstants::kPid] ;          // Array of probability to be   (e,mu,pi,k,p,d)
   Int_t    fFitPts[4] ;                        // Array of Fit Points          (in: TPC,ITS,TRD,TOF)
   Int_t    fMaxPts[4] ;                        // Array of Foundable Clusters  (in: TPC,ITS,TRD,TOF)
   Float_t  fFitChi2[4] ;                       // Array of Chi2                (in: TPC,ITS,TRD,TOF)
@@ -183,8 +181,8 @@ private:
   Float_t  fMom[4] ;                           // Array of momentum at the entrance of TPC,ITS,TRD,TOF     
 
  // Selection's array for R.P. & sub-event selection (not stored)  
-  Bool_t   fSelection[Flow::nHars][Flow::nSels]; //! 
-  Short_t  fSubevent[Flow::nHars][Flow::nSels];         //! 
+  Bool_t   fSelection[AliFlowConstants::kHars][AliFlowConstants::kSels]; //! 
+  Short_t  fSubevent[AliFlowConstants::kHars][AliFlowConstants::kSels];         //! 
 
   ClassDef(AliFlowTrack,4) ;                   // macro for rootcint
 };
index 6297bd38a05aa303ee87e3457d1a90e97120b02f..e1472c9f024c722fee123713a357e464707c15df 100644 (file)
@@ -1,4 +1,4 @@
-       //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
 //
 // $Id$
 //
@@ -21,8 +21,8 @@
 //
 //////////////////////////////////////////////////////////////////////
 
-#ifndef ALIFLOWANALYSER_CXX
-#define ALIFLOWANALYSER_CXX
+#ifndef ALIFLOWWEIGHTER_CXX
+#define ALIFLOWWEIGHTER_CXX
 
 // ROOT things
 #include <TROOT.h>
@@ -91,22 +91,22 @@ Bool_t AliFlowWeighter::Init()
  //for(Int_t ii=0;ii<3;ii++) { fVertex[ii] = 0 ; }
 
  // Histogram settings
- fPhiBins = Flow::nPhiBins ;     
+ fPhiBins = AliFlowConstants::kPhiBins ;     
  fPhiMin  = 0.;
  fPhiMax  = 2*TMath::Pi() ; 
 
  TString* histTitle ;
- for(int k = 0; k < Flow::nSels; k++)
+ for(int k = 0; k < AliFlowConstants::kSels; k++)
  {
   histTitle = new TString("Flow_BayPidMult_Sel");
   *histTitle += k+1;
-  fHistFull[k].fHistBayPidMult = new TH1F(histTitle->Data(), histTitle->Data(),Flow::nPid,-0.5,((Float_t)Flow::nPid-0.5));
+  fHistFull[k].fHistBayPidMult = new TH1F(histTitle->Data(), histTitle->Data(),AliFlowConstants::kPid,-0.5,((Float_t)AliFlowConstants::kPid-0.5));
   fHistFull[k].fHistBayPidMult->Sumw2() ;
   fHistFull[k].fHistBayPidMult->SetXTitle("e+/-  ,  mu+/-  ,  pi+/-  ,  K+/-  ,  p+/-  ,  d+/- ");
   fHistFull[k].fHistBayPidMult->SetYTitle("Counts");
   delete histTitle;
 
-  for(int j = 0; j < Flow::nHars; j++) 
+  for(int j = 0; j < AliFlowConstants::kHars; j++) 
   {
    // Tpc - Phi lab
    histTitle = new TString("Flow_Phi_TPC_Sel");
@@ -204,7 +204,7 @@ Bool_t AliFlowWeighter::Finish()
  delete fPhiWgtHistList ;
  
  // Write Bayesian Weights for P.Id.
- for(int k=0;k<Flow::nSels;k++) { fHistFull[k].fHistBayPidMult->Write() ; }
+ for(int k=0;k<AliFlowConstants::kSels;k++) { fHistFull[k].fHistBayPidMult->Write() ; }
 
  // Write the AliFlowSelection object
  fFlowSelect->Write();
@@ -279,10 +279,10 @@ void AliFlowWeighter::TracksLoop(TObjArray* fFlowTracks)
   else if(strstr(pid,"d"))  { fPidId = 5 ; }
 
   // Looping over Selections and Harmonics
-  for (int k = 0; k < Flow::nSels; k++) 
+  for (int k = 0; k < AliFlowConstants::kSels; k++) 
   {
    fFlowSelect->SetSelection(k) ;
-   for (int j = 0; j < Flow::nHars; j++) 
+   for (int j = 0; j < AliFlowConstants::kHars; j++) 
    {
     fFlowSelect->SetHarmonic(j);
     if(fFlowSelect->Select(fFlowTrack))
@@ -324,13 +324,13 @@ Bool_t AliFlowWeighter::Weightening()
  cout << " AliFlowWeighter::Weightening() " << endl ; cout << endl ;
  
  // PhiWgt histogram collection
- fPhiWgtHistList = new TOrdCollection(4*Flow::nSels*Flow::nHars) ;
+ fPhiWgtHistList = new TOrdCollection(4*AliFlowConstants::kSels*AliFlowConstants::kHars) ;
  
  // Creates PhiWgt Histograms
  TString* histTitle ;
- for(Int_t k = 0; k < Flow::nSels; k++)
+ for(Int_t k = 0; k < AliFlowConstants::kSels; k++)
  {
-  for(Int_t j = 0; j < Flow::nHars; j++) 
+  for(Int_t j = 0; j < AliFlowConstants::kHars; j++) 
   {
    // Tpc plus
    histTitle = new TString("Flow_Phi_Weight_TPCplus_Sel");
@@ -411,19 +411,19 @@ Bool_t AliFlowWeighter::Weightening()
  return kTRUE ;
 }
 //-----------------------------------------------------------------------
-void AliFlowWeighter::PrintBayesian(Int_t selN)  
+void AliFlowWeighter::PrintBayesian(Int_t selN) const
 {
  // Prints the normalized particle abundance of all events (selection selN).
  // Call this at the end of the loop, just before Finish() .
 
- if(selN>Flow::nSels) { selN = 0 ; } 
- Char_t* names[Flow::nPid] = {"e","mu","pi","k","p","d"} ;
+ if(selN>AliFlowConstants::kSels) { selN = 0 ; } 
+ Char_t* names[AliFlowConstants::kPid] = {"e","mu","pi","k","p","d"} ;
  Double_t bayes = 0. ;
  Double_t totCount = (fHistFull[selN].fHistBayPidMult)->GetSumOfWeights() ;
  if(totCount) 
  { 
   cout << " Sel." << selN << " particles normalized abundance (tot. " << totCount << " tracks) : " ;
-  for(Int_t ii=0;ii<Flow::nPid;ii++)
+  for(Int_t ii=0;ii<AliFlowConstants::kPid;ii++)
   {
    bayes = (fHistFull[selN].fHistBayPidMult->GetBinContent(ii+1) / totCount) ; 
    cout << bayes << "_" << names[ii] << " ; " ;
index da4c245f40a281a1d40854d16d8e498dfdc18ff0..b0dd31524adea8fdb187d85d0212bae1ac9cbb09 100644 (file)
@@ -7,25 +7,27 @@
 //////////////////////////////////////////////////////////////////////
 //
 // Description: generates phi-weights and counts particle abundances .
+//  So, in fact, you should run this thing before the analysis,
+//  if you want to use phi-weight.
 //
 //////////////////////////////////////////////////////////////////////
 
-#ifndef ALIFLOWEIGHTER_H
-#define ALIFLOWEIGHTER_H
+#ifndef ALIFLOWWEIGHTER_H
+#define ALIFLOWWEIGHTER_H
 
-#include <TVector2.h>
 #include <TFile.h>
 #include "AliFlowConstants.h"
 
 class TH1F;
 class TH1D;
 class TOrdCollection;
+class TVector2;
 
 class AliFlowTrack;
 class AliFlowV0;
 class AliFlowEvent;
 class AliFlowSelection;
-class Flow;
+class AliFlowConstants;
 
 class AliFlowWeighter {
 
@@ -47,7 +49,7 @@ class AliFlowWeighter {
   void    SetWgtFile(TFile* file)                              { fWgtFile = file ; fWgtFileName = fWgtFile->GetName() ; }  // Sets output file
   TString  GetWgtFileName() const                              { return fWgtFileName ; }
 
-  void            PrintBayesian(Int_t selN = 0) ;                      // Prints normalized particle abundance (selN)
+  void            PrintBayesian(Int_t selN = 0) const ;                // Prints normalized particle abundance (selN)
 
 
  protected:
@@ -59,15 +61,18 @@ class AliFlowWeighter {
 
  private:
 
+  //AliFlowWeighter(const AliFlowWeighter &flowWgt)            { flowWgt.fPhiBins ; }  // Copy Constructor (dummy)
+  //AliFlowWeighter &operator=(const AliFlowWeighter &flowAnal) { return *this ; }     // Assignment Operator
+
  // enumerators etc.                       
   Int_t            fEventNumber ;                              //! progressive enumeration of AliFlowEvents
   Int_t            fTrackNumber ;                              //! progressive enumeration of AliFlowTracks
   Int_t            fNumberOfV0s ;                              //! total number of V0s in the current event
   Int_t           fNumberOfTracks ;                            //! total number of tracks in the current event
 
-  Int_t            fPhiBins ;     
-  Float_t         fPhiMin ;
-  Float_t         fPhiMax ; 
+  Int_t            fPhiBins ;                                  //! phi bins   
+  Float_t         fPhiMin ;                                    //! i.e. 0
+  Float_t         fPhiMax ;                                    //! i.e. 2 Pi
 
  // Internal pointers
   AliFlowEvent*     fFlowEvent ;                               //! pointer to AliFlowEvent
@@ -82,30 +87,28 @@ class AliFlowWeighter {
 
  // Histograms
   TOrdCollection*   fPhiWgtHistList ;                          //! Weights:  histogram list
-  struct fHistFullHars 
+  struct AliHistFullHars 
   {
-    TH1D*       fHistPhiPlus;
-    TH1D*       fHistPhiMinus;
-    TH1D*       fHistPhiAll;
-    TH1D*       fHistPhi;
-    TH1D*       fHistPhiWgtPlus;
-    TH1D*       fHistPhiWgtMinus;
-    TH1D*       fHistPhiWgtAll;
-    TH1D*       fHistPhiWgt;
-    TH1D*       fHistPhiFlatPlus;
-    TH1D*       fHistPhiFlatMinus;
-    TH1D*       fHistPhiFlatAll;
-    TH1D*       fHistPhiFlat;
+    TH1D*       fHistPhiPlus;                                  //! histogram ...
+    TH1D*       fHistPhiMinus;                                 //! histogram ...
+    TH1D*       fHistPhiAll;                                   //! histogram ...
+    TH1D*       fHistPhi;                                      //! histogram ...
+    TH1D*       fHistPhiWgtPlus;                               //! histogram ...
+    TH1D*       fHistPhiWgtMinus;                              //! histogram ...
+    TH1D*       fHistPhiWgtAll;                                //! histogram ...
+    TH1D*       fHistPhiWgt;                                   //! histogram ...
+    TH1D*       fHistPhiFlatPlus;                              //! histogram ...
+    TH1D*       fHistPhiFlatMinus;                             //! histogram ...
+    TH1D*       fHistPhiFlatAll;                               //! histogram ...
+    TH1D*       fHistPhiFlat;                                  //! histogram ...
   };
   
-  struct fHistFulls;   
-  friend struct fHistFulls;
-  struct fHistFulls 
+  struct AliHistFulls 
   {
-   TH1F*       fHistBayPidMult;
-   struct fHistFullHars fHistFullHar[Flow::nHars];             // wgt, evts, trks, v0s (as defined above)
+   TH1F*       fHistBayPidMult ;                               //! histogram ...
+   struct AliHistFullHars fHistFullHar[AliFlowConstants::kHars];               //! structure wgt, evts, trks, v0s (as defined above)
   };
-  struct fHistFulls fHistFull[Flow::nSels];                     //!
+  struct AliHistFulls fHistFull[AliFlowConstants::kSels];                   //! structure array ...
 
   ClassDef(AliFlowWeighter,0)                                  // macro for rootcint
 };
index 56e59288de7169ae066a21d2c06701239fa8c77d..71cc93ef9e5be30688e064848221e44c51f65da8 100644 (file)
@@ -170,7 +170,7 @@ void AliSelectorFoF::Begin(TTree*)
   fFlowSelect->SetCentralityCut(-1) ;
   fFlowSelect->SetRunIdCut(-1) ;
   // R.P. calculation cuts
-  for(int j=0;j<Flow::nHars;j++)
+  for(int j=0;j<AliFlowConstants::kHars;j++)
   {
    fFlowSelect->SetEtaCut(0., 1.1, j, 1) ;
    fFlowSelect->SetPtCut(0.1, 10. , j, 1);
index 538999c0c1686a0af425abdb10866b71188a45f8..4732105eb44479bbd89024f417f34a321b7e6807 100644 (file)
@@ -2,8 +2,8 @@
 /* derived from AliSelector.h,v 1.10 2006/08/15 jgrosseo Exp */
 
 // This selector is only dependent on the ESD library, if you need the whole of AliROOT use AliSelectorRL
-#ifndef ALISELECTORF_H
-#define ALISELECTORF_H
+#ifndef ALISELECTORFOF_H
+#define ALISELECTORFOF_H
 
 #include <TSelector.h>
 
@@ -12,6 +12,7 @@ class AliFlowSelection;
 class AliFlowMaker;
 class AliFlowAnalyser; 
 class AliFlowWeighter;
+class AliFlowConstants;
 
 class AliESD;
 class AliESDtrack;
index 24eb40fb38f3856b8ce1ddb86046c9d6c4ba3d86..8b559e19c0cd66f1faf6f6ce22bf4f4567f5fd19 100644 (file)
@@ -22,7 +22,7 @@
 
 using namespace std; //required for resolving the 'cout' symbol
 
-void testAnal(TString output = "pFlowEvtsAnal.root")
+void testAnal(TString output = "flowEvtsAnal.root")
 {
  cout << " . Here the new flow analysis (2007) ... " << endl ;
  cout << endl ;
@@ -50,7 +50,7 @@ void testAnal(TString output = "pFlowEvtsAnal.root")
  select->SetRunIdCut(-1) ;
 
  // R.P. calculation cuts
- for(int j=0;j<Flow::nHars;j++)
+ for(int j=0;j<AliFlowConstants::kHars;j++)
  {
   select->SetEtaCut(0., 1.1, j, 1) ;
   select->SetPtCut(0.1, 10. , j, 1);
@@ -107,7 +107,7 @@ void testAnal(TString output = "pFlowEvtsAnal.root")
  cout << " . Writing Histograms on  : " << flow->GetHistFileName()   << "  . " << endl ;
 
  // Wgt file
- TString wgtFileName = "pFlowPhiWgt.root" ;
+ TString wgtFileName = "flowPhiWgt.root" ;
  TFile* wgtFile = new TFile(wgtFileName.Data(),"READ");
  flow->FillWgtArrays(wgtFile) ; // fix this !!!
  cout << " . Weights from  : " << flow->GetWgtFileName() << "  . " << endl ;
@@ -130,7 +130,7 @@ void testAnal(TString output = "pFlowEvtsAnal.root")
  
  // flowEvents chain (imput) //
 
- TString fFlowFileName = "pFlowEvts.root" ;
+ TString fFlowFileName = "flowEvts.root" ;
 
  // organizing event loop
  TFile* flowEventsFile = new TFile(fFlowFileName.Data(), "READ") ; // flowEventsFile->ls() ;
index 6680a0517ab2550754dad35aaf3b4281326eef47..bd4c21e06b62d3bf38dfbd9b1d83b4204ccc57ea 100644 (file)
@@ -20,7 +20,7 @@
 
 using namespace std; //required for resolving the 'cout' symbol
 
-void testMaker(TString output = "pFlowEvts.root")
+void testMaker(TString output = "flowEvts.root")
 {
  cout << " . Here the new flow maker (2007) ... " << endl ;
  cout << endl ;
@@ -54,6 +54,12 @@ void testMaker(TString output = "pFlowEvts.root")
   pESDchain->Add("1/AliESDs.root") ; // nFiles++ ;
   pESDchain->Add("2/AliESDs.root") ; // nFiles++ ;
   pESDchain->Add("3/AliESDs.root") ; // nFiles++ ;
+  pESDchain->Add("4/AliESDs.root") ; // nFiles++ ;
+  pESDchain->Add("5/AliESDs.root") ; // nFiles++ ;
+  pESDchain->Add("6/AliESDs.root") ; // nFiles++ ;
+  pESDchain->Add("7/AliESDs.root") ; // nFiles++ ;
+  pESDchain->Add("8/AliESDs.root") ; // nFiles++ ;
+  pESDchain->Add("9/AliESDs.root") ; // nFiles++ ;
  }
 
  Int_t fNumberOfEvents = (Int_t)pESDchain->GetEntries() ;
index c07e53dec5659da009d835cd0c22b4590e1735c8..50a7b611004f57a81528cf401f2d6e289d6cf8c5 100644 (file)
@@ -22,7 +22,7 @@
 
 using namespace std; //required for resolving the 'cout' symbol
 
-void testWeight(TString wgts = "pFlowPhiWgt.root")
+void testWeight(TString wgts = "flowPhiWgt.root")
 {
  cout << " . Here the new flow Weighter (2007) ... " << endl ;
  cout << endl ;
@@ -49,7 +49,7 @@ void testWeight(TString wgts = "pFlowPhiWgt.root")
  select->SetRunIdCut(-1) ;
 
  // R.P. calculation cuts
- for(int j=0;j<Flow::nHars;j++)
+ for(int j=0;j<AliFlowConstants::kHars;j++)
  {
   select->SetEtaCut(0., 1.1, j, 1) ;
   select->SetPtCut(0.1, 10. , j, 1);
@@ -79,7 +79,7 @@ void testWeight(TString wgts = "pFlowPhiWgt.root")
  
  // flowEvents chain (imput) //
 
- TString input = "pFlowEvts.root" ;
+ TString input = "flowEvts.root" ;
  TFile* flowEventsFile = new TFile(input.Data(), "READ") ; // flowEventsFile->ls() ;
  Int_t nEvts = flowEventsFile->GetNkeys() ; 
  cout << " . Found  " << nEvts << " AliFlowEvents in file " << input.Data() << endl ;