Fixes for wrong use of const causing PW.CAST_TO_QUALIFIED_TYPE defect in Coverity
authorhristov <Peter.Hristov@cern.ch>
Wed, 30 Apr 2014 05:00:22 +0000 (07:00 +0200)
committerhristov <Peter.Hristov@cern.ch>
Wed, 30 Apr 2014 05:00:22 +0000 (07:00 +0200)
19 files changed:
EVGEN/AliGenEMlib.cxx
EVGEN/AliGenEMlib.h
ITS/UPGRADE/AliITSUVertexer.h
PWG/FLOW/Base/AliFlowAnalysisWithMultiparticleCorrelations.cxx
PWG/FLOW/Base/AliFlowAnalysisWithMultiparticleCorrelations.h
PWG/FLOW/Tasks/AliAnalysisTaskMultiparticleCorrelations.cxx
PWG/FLOW/Tasks/AliAnalysisTaskMultiparticleCorrelations.h
PWGCF/Correlations/Base/AliTwoPlusOneContainer.cxx
PWGCF/Correlations/Base/AliTwoPlusOneContainer.h
PWGHF/hfe/AliHFEV0taginfo.cxx
PWGHF/hfe/AliHFEV0taginfo.h
PWGHF/hfe/AliHFEmcQA.cxx
PWGHF/hfe/AliHFEmcQA.h
TPC/Base/AliTPCCorrection.cxx
TPC/Base/AliTPCCorrection.h
TPC/Rec/AliTPCtracker.cxx
TPC/Rec/AliTPCtracker.h
TPC/Upgrade/AliToyMCEventGeneratorSimple.cxx
TPC/Upgrade/AliToyMCEventGeneratorSimple.h

index ff46597..26305cf 100644 (file)
@@ -40,12 +40,12 @@ Int_t AliGenEMlib::fgSelectedPtParam=AliGenEMlib::kPizero7TeVpp;
 Int_t AliGenEMlib::fgSelectedCentrality=AliGenEMlib::kpp;
 Int_t AliGenEMlib::fgSelectedV2Systematic=AliGenEMlib::kNoV2Sys;
 
-Double_t AliGenEMlib::CrossOverLc(const double a, const double b, const double x){
+Double_t AliGenEMlib::CrossOverLc(double a, double b, double x){
   if(x<b-a/2) return 1.0;
   else if(x>b+a/2) return 0.0;
   else return cos(((x-b)/a+0.5)*TMath::Pi())/2+0.5;
 }
-Double_t AliGenEMlib::CrossOverRc(const double a, const double b, const double x){
+Double_t AliGenEMlib::CrossOverRc(double a, double b, double x){
   return 1-CrossOverLc(a,b,x);
 }
 
@@ -136,13 +136,13 @@ const Double_t AliGenEMlib::fgkMtFactor[2][8] = {
 //                              General functions
 //
 //--------------------------------------------------------------------------
-Double_t AliGenEMlib::PtModifiedHagedornThermal(const Double_t pt,
-                                                const Double_t c,
-                                                const Double_t p0,
-                                                const Double_t p1,
-                                                const Double_t n,
-                                                const Double_t cT,
-                                                const Double_t T)
+Double_t AliGenEMlib::PtModifiedHagedornThermal(Double_t pt,
+                                                Double_t c,
+                                                Double_t p0,
+                                                Double_t p1,
+                                                Double_t n,
+                                                Double_t cT,
+                                                Double_t T)
 {
   // Modified Hagedorn Thermal fit to Picharged for PbPb:
   Double_t invYield;
@@ -153,12 +153,12 @@ Double_t AliGenEMlib::PtModifiedHagedornThermal(const Double_t pt,
 
 
 
-Double_t AliGenEMlib::PtModifiedHagedornExp(const Double_t pt,
-                                           const Double_t c,
-                                           const Double_t p1,
-                                           const Double_t p2,
-                                           const Double_t p0,
-                                           const Double_t n)
+Double_t AliGenEMlib::PtModifiedHagedornExp(Double_t pt,
+                                           Double_t c,
+                                           Double_t p1,
+                                           Double_t p2,
+                                           Double_t p0,
+                                           Double_t n)
 {
   // Modified Hagedorn exponentiel fit to Pizero for PbPb:
   Double_t invYield;
@@ -168,14 +168,14 @@ Double_t AliGenEMlib::PtModifiedHagedornExp(const Double_t pt,
 }
 
 
-Double_t AliGenEMlib::PtModifiedHagedornExp2(const Double_t pt,
-                                             const Double_t c,
-                                             const Double_t a,
-                                             const Double_t b,
-                                             const Double_t p0,
-                                             const Double_t p1,
-                                             const Double_t d,
-                                             const Double_t n)
+Double_t AliGenEMlib::PtModifiedHagedornExp2(Double_t pt,
+                                             Double_t c,
+                                             Double_t a,
+                                             Double_t b,
+                                             Double_t p0,
+                                             Double_t p1,
+                                             Double_t d,
+                                             Double_t n)
 {
   // Modified Hagedorn exponential fit to charged pions for pPb:
   Double_t invYield;
@@ -184,11 +184,11 @@ Double_t AliGenEMlib::PtModifiedHagedornExp2(const Double_t pt,
   return invYield*(2*TMath::Pi()*pt);
 }
 
-Double_t AliGenEMlib::PtTsallis(const Double_t pt,
-                                const Double_t m,
-                                const Double_t c,
-                                const Double_t T,
-                                const Double_t n)
+Double_t AliGenEMlib::PtTsallis(Double_t pt,
+                                Double_t m,
+                                Double_t c,
+                                Double_t T,
+                                Double_t n)
 {
   // Tsallis fit to Pizero for pp:
   Double_t mt;
@@ -825,7 +825,7 @@ Double_t AliGenEMlib::MtScal(Double_t pt, Int_t np)
   return norm*(pt/scaledPt)*scaledYield;
 }
 
-Double_t AliGenEMlib::KEtScal(const Double_t pt, Int_t np)
+Double_t AliGenEMlib::KEtScal(Double_t pt, Int_t np)
 {
   const int nq=2; //number of quarks for particle np, here always 2
   Double_t scaledPt = sqrt(pow(2.0/nq*(sqrt(pt*pt+fgkHM[np]*fgkHM[np])-fgkHM[np])+fgkHM[0],2)-fgkHM[0]*fgkHM[0]);
index 95af158..cf43e6f 100644 (file)
@@ -45,39 +45,39 @@ public:
   static Int_t fgSelectedV2Systematic; // selected v2 systematics, usefully values: -1,0,1
 
 
-  static Double_t PtModifiedHagedornThermal(const Double_t pt, 
-                                           const Double_t c, 
-                                           const Double_t p0, 
-                                           const Double_t p1, 
-                                           const Double_t n,
-                                           const Double_t cT,
-                                           const Double_t T);
+  static Double_t PtModifiedHagedornThermal(Double_t pt, 
+                                           Double_t c, 
+                                           Double_t p0, 
+                                           Double_t p1, 
+                                           Double_t n,
+                                           Double_t cT,
+                                           Double_t T);
 
 
  
-  static Double_t PtModifiedHagedornExp(const Double_t pt,
-                                       const Double_t c,
-                                       const Double_t p0,
-                                       const Double_t p1,
-                                       const Double_t p2,
-                                       const Double_t n); 
-
-
-  static Double_t PtModifiedHagedornExp2(const Double_t pt,
-                                           const Double_t c,
-                                           const Double_t a,
-                                           const Double_t b,
-                                           const Double_t p0,
-                                           const Double_t p1,
-                                           const Double_t d,
-                                           const Double_t n);
-
-
-  static Double_t PtTsallis(const Double_t pt,
-                           const Double_t m,
-                           const Double_t c,
-                           const Double_t T,
-                           const Double_t n);
+  static Double_t PtModifiedHagedornExp(Double_t pt,
+                                       Double_t c,
+                                       Double_t p0,
+                                       Double_t p1,
+                                       Double_t p2,
+                                       Double_t n); 
+
+
+  static Double_t PtModifiedHagedornExp2(Double_t pt,
+                                           Double_t c,
+                                           Double_t a,
+                                           Double_t b,
+                                           Double_t p0,
+                                           Double_t p1,
+                                           Double_t d,
+                                           Double_t n);
+
+
+  static Double_t PtTsallis(Double_t pt,
+                           Double_t m,
+                           Double_t c,
+                           Double_t T,
+                           Double_t n);
 
   static Double_t PtExponential(const Double_t *pt, const Double_t *param);
   static Double_t PtModifiedHagedornPowerlaw(const Double_t *pt, const Double_t *param);
@@ -151,8 +151,8 @@ public:
   static Double_t KEtScal(Double_t pt, Int_t np);
   static Double_t GetTAA(Int_t cent);
 
-  static Double_t CrossOverLc(const double a, const double b, const double x);
-  static Double_t CrossOverRc(const double a, const double b, const double x);
+  static Double_t CrossOverLc(double a, double b, double x);
+  static Double_t CrossOverRc(double a, double b, double x);
 
   static const Double_t fgkV2param[16][15];          // parameters of pi v2
   static const Double_t fgkRawPtOfV2Param[16][10];   // parameters of the raw pt spectrum of v2 analysys
index 89e7e25..b9628d9 100644 (file)
@@ -31,8 +31,8 @@ class AliITSUVertexer : public AliVertexer {
   UShort_t GetNumOfVertices() const { return fNoVertices; }
 
   // Setters
-  void SetPhiCut(const Double_t phicut) { fPhiCut=phicut; }
-  void SetZCut(const Double_t zcut)     { fZCut=zcut; }
+  void SetPhiCut(Double_t phicut) { fPhiCut=phicut; }
+  void SetZCut(Double_t zcut)     { fZCut=zcut; }
 
   #ifdef MC_CHECK
   // Debug + MC truth
index a7a0d5b..21961c1 100644 (file)
@@ -4658,11 +4658,11 @@ void AliFlowAnalysisWithMultiparticleCorrelations::InitializeArraysForWeights()
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)
 {
  // Set number of bins for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -4685,15 +4685,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, co
 
  fnBins[rp][ppe] = nBins;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)
 {
  // Set min bin range for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -4716,15 +4716,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, cons
 
  fMin[rp][ppe] = min;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t max)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t max)
 {
  // Set max bin range for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t max)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t max)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -4747,15 +4747,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, cons
 
  fMax[rp][ppe] = max;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t min)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t min)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)
 {
  // Set number of bins for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -4770,15 +4770,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type
 
  fnBinsMult[rpr] = nBinsMult;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, const Double_t minMult)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)
 {
  // Set min bin range for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, const Double_t minMult)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -4793,15 +4793,15 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type,
 
  fMinMult[rpr] = minMult;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type const Double_t minMult)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)
 
 //=======================================================================================================================
 
-void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, const Double_t maxMult)
+void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, Double_t maxMult)
 {
  // Set max bin range for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, const Double_t maxMult)";
+ TString sMethodName = "void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, Double_t maxMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -4816,7 +4816,7 @@ void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type,
 
  fMaxMult[rpr] = maxMult;
 
-} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, const Double_t minMult)
+} // void AliFlowAnalysisWithMultiparticleCorrelations::SetMaxMult(const char *type, Double_t minMult)
 
 //=======================================================================================================================
 
index fe40152..d977a62 100644 (file)
@@ -103,28 +103,28 @@ class AliFlowAnalysisWithMultiparticleCorrelations{
   TList* GetHistList() const {return this->fHistList;} 
   void SetInternalFlagsPro(TProfile* const ifp) {this->fInternalFlagsPro = ifp;};
   TProfile* GetInternalFlagsPro() const {return this->fInternalFlagsPro;}; 
-  void SetMinNoRPs(Int_t const min) {fUseInternalFlags = kTRUE; this->fMinNoRPs = min;};
+  void SetMinNoRPs(Int_t min) {fUseInternalFlags = kTRUE; this->fMinNoRPs = min;};
   Int_t GetMinNoRPs() const {return this->fMinNoRPs;};
-  void SetMaxNoRPs(Int_t const max) {fUseInternalFlags = kTRUE; this->fMaxNoRPs = max;};
+  void SetMaxNoRPs(Int_t max) {fUseInternalFlags = kTRUE; this->fMaxNoRPs = max;};
   Int_t GetMaxNoRPs() const {return this->fMaxNoRPs;};
-  void SetExactNoRPs(Int_t const exact) {fUseInternalFlags = kTRUE; this->fExactNoRPs = exact;};
+  void SetExactNoRPs(Int_t exact) {fUseInternalFlags = kTRUE; this->fExactNoRPs = exact;};
   Int_t GetExactNoRPs() const {return this->fExactNoRPs;};
   void SetAnalysisTag(const char *at) {this->fAnalysisTag = TString(at);};
   TString GetAnalysisTag() const {return this->fAnalysisTag;};
-  void SetDumpThePoints(Bool_t const dtp, Int_t const max) {this->fDumpThePoints = dtp; this->fMaxNoEventsPerFile = max;};
+  void SetDumpThePoints(Bool_t dtp, Int_t max) {this->fDumpThePoints = dtp; this->fMaxNoEventsPerFile = max;};
 
   //  5.1.) Control histograms:  
   void SetControlHistogramsList(TList* const chl) {this->fControlHistogramsList = chl;};
   TList* GetControlHistogramsList() const {return this->fControlHistogramsList;} 
   void SetControlHistogramsFlagsPro(TProfile* const chfp) {this->fControlHistogramsFlagsPro = chfp;};
   TProfile* GetControlHistogramsFlagsPro() const {return this->fControlHistogramsFlagsPro;}; 
-  void SetFillControlHistograms(Bool_t const fch) {this->fFillControlHistograms = fch;};
+  void SetFillControlHistograms(Bool_t fch) {this->fFillControlHistograms = fch;};
   Bool_t GetFillControlHistograms() const {return this->fFillControlHistograms;};
-  void SetFillKinematicsHist(Bool_t const fkh) {this->fFillKinematicsHist = fkh;};
+  void SetFillKinematicsHist(Bool_t fkh) {this->fFillKinematicsHist = fkh;};
   Bool_t GetFillKinematicsHist() const {return this->fFillKinematicsHist;};
-  void SetFillMultDistributionsHist(Bool_t const mdh) {this->fFillMultDistributionsHist = mdh;};
+  void SetFillMultDistributionsHist(Bool_t mdh) {this->fFillMultDistributionsHist = mdh;};
   Bool_t GetFillMultDistributionsHist() const {return this->fFillMultDistributionsHist;};
-  void SetFillMultCorrelationsHist(Bool_t const mch) {this->fFillMultCorrelationsHist = mch;};
+  void SetFillMultCorrelationsHist(Bool_t mch) {this->fFillMultCorrelationsHist = mch;};
   Bool_t GetFillMultCorrelationsHist() const {return this->fFillMultCorrelationsHist;};
   void SetDontFill(const char *type) 
   {
@@ -133,21 +133,21 @@ class AliFlowAnalysisWithMultiparticleCorrelations{
    else if(TString(type).EqualTo("REF")){this->fDontFill[2] = kTRUE;} 
    else{Fatal("void SetDontFill(const char *type)","type = %s ???? Allowed: RP, POI and REF.",type);}
   }; // void SetDontFill(const char *type) 
-  void SetnBins(const char *type, const char *variable, const Int_t nBins); // .cxx
-  void SetMin(const char *type, const char *variable, const Double_t min); // .cxx
-  void SetMax(const char *type, const char *variable, const Double_t max); // .cxx
-  void SetnBinsMult(const char *type, const Int_t nBinsMult); // .cxx
-  void SetMinMult(const char *type, const Double_t minMult); // .cxx
-  void SetMaxMult(const char *type, const Double_t maxMult); // .cxx
+  void SetnBins(const char *type, const char *variable, Int_t nBins); // .cxx
+  void SetMin(const char *type, const char *variable, Double_t min); // .cxx
+  void SetMax(const char *type, const char *variable, Double_t max); // .cxx
+  void SetnBinsMult(const char *type, Int_t nBinsMult); // .cxx
+  void SetMinMult(const char *type, Double_t minMult); // .cxx
+  void SetMaxMult(const char *type, Double_t maxMult); // .cxx
 
   //  5.2.) Q-vectors:
   void SetQvectorList(TList* const qvl) {this->fQvectorList = qvl;};
   TList* GetQvectorList() const {return this->fQvectorList;} 
   void SetQvectorFlagsPro(TProfile* const qvfp) {this->fQvectorFlagsPro = qvfp;};
   TProfile* GetQvectorFlagsPro() const {return this->fQvectorFlagsPro;}; 
-  void SetCalculateQvector(Bool_t const cqv) {this->fCalculateQvector = cqv;};
+  void SetCalculateQvector(Bool_t cqv) {this->fCalculateQvector = cqv;};
   Bool_t GetCalculateQvector() const {return this->fCalculateQvector;};
-  void SetCalculateDiffQvectors(Bool_t const cdqv) {this->fCalculateDiffQvectors = cdqv;};
+  void SetCalculateDiffQvectors(Bool_t cdqv) {this->fCalculateDiffQvectors = cdqv;};
   Bool_t GetCalculateDiffQvectors() const {return this->fCalculateDiffQvectors;};
 
   //  5.3.) Correlations:
@@ -155,27 +155,27 @@ class AliFlowAnalysisWithMultiparticleCorrelations{
   TList* GetCorrelationsList() const {return this->fCorrelationsList;} 
   void SetCorrelationsFlagsPro(TProfile* const cfp) {this->fCorrelationsFlagsPro = cfp;};
   TProfile* GetCorrelationsFlagsPro() const {return this->fCorrelationsFlagsPro;}; 
-  void SetCalculateCorrelations(Bool_t const cc) {this->fCalculateCorrelations = cc;};
+  void SetCalculateCorrelations(Bool_t cc) {this->fCalculateCorrelations = cc;};
   Bool_t GetCalculateCorrelations() const {return this->fCalculateCorrelations;};
-  void SetCalculateIsotropic(Bool_t const ci) {this->fCalculateIsotropic = ci;};
+  void SetCalculateIsotropic(Bool_t ci) {this->fCalculateIsotropic = ci;};
   Bool_t GetCalculateIsotropic() const {return this->fCalculateIsotropic;};
-  void SetCalculateSame(Bool_t const cs) {this->fCalculateSame = cs;};
+  void SetCalculateSame(Bool_t cs) {this->fCalculateSame = cs;};
   Bool_t GetCalculateSame() const {return this->fCalculateSame;};
-  void SetSkipZeroHarmonics(Bool_t const szh) {this->fSkipZeroHarmonics = szh;};
+  void SetSkipZeroHarmonics(Bool_t szh) {this->fSkipZeroHarmonics = szh;};
   Bool_t GetSkipZeroHarmonics() const {return this->fSkipZeroHarmonics;};
-  void SetCalculateSameIsotropic(Bool_t const csi) {this->fCalculateSameIsotropic = csi;};
+  void SetCalculateSameIsotropic(Bool_t csi) {this->fCalculateSameIsotropic = csi;};
   Bool_t GetCalculateSameIsotropic() const {return this->fCalculateSameIsotropic;};
-  void SetCalculateAll(Bool_t const ca) {this->fCalculateAll = ca;};
+  void SetCalculateAll(Bool_t ca) {this->fCalculateAll = ca;};
   Bool_t GetCalculateAll() const {return this->fCalculateAll;};
-  void SetDontGoBeyond(Int_t const dgb) {this->fDontGoBeyond = dgb;};
+  void SetDontGoBeyond(Int_t dgb) {this->fDontGoBeyond = dgb;};
   Int_t GetDontGoBeyond() const {return this->fDontGoBeyond;};
-  void SetCalculateOnlyForHarmonicQC(Bool_t const cofhqc) {this->fCalculateOnlyForHarmonicQC = cofhqc;};
+  void SetCalculateOnlyForHarmonicQC(Bool_t cofhqc) {this->fCalculateOnlyForHarmonicQC = cofhqc;};
   Bool_t GetCalculateOnlyForHarmonicQC() const {return this->fCalculateOnlyForHarmonicQC;};
-  void SetCalculateOnlyForSC(Bool_t const cofsc) {this->fCalculateOnlyForSC = cofsc;};
+  void SetCalculateOnlyForSC(Bool_t cofsc) {this->fCalculateOnlyForSC = cofsc;};
   Bool_t GetCalculateOnlyForSC() const {return this->fCalculateOnlyForSC;};
-  void SetCalculateOnlyCos(Bool_t const coc) {this->fCalculateOnlyCos = coc;};
+  void SetCalculateOnlyCos(Bool_t coc) {this->fCalculateOnlyCos = coc;};
   Bool_t GetCalculateOnlyCos() const {return this->fCalculateOnlyCos;};
-  void SetCalculateOnlySin(Bool_t const cos) {this->fCalculateOnlySin = cos;};
+  void SetCalculateOnlySin(Bool_t cos) {this->fCalculateOnlySin = cos;};
   Bool_t GetCalculateOnlySin() const {return this->fCalculateOnlySin;};
 
   //  5.4.) Event-by-event cumulants:
@@ -183,7 +183,7 @@ class AliFlowAnalysisWithMultiparticleCorrelations{
   TList* GetEbECumulantsList() const {return this->fEbECumulantsList;} 
   void SetEbECumulantsFlagsPro(TProfile* const ebecfp) {this->fEbECumulantsFlagsPro = ebecfp;};
   TProfile* GetEbECumulantsFlagsPro() const {return this->fEbECumulantsFlagsPro;}; 
-  void SetCalculateEbECumulants(Bool_t const cebec) {this->fCalculateEbECumulants = cebec;};
+  void SetCalculateEbECumulants(Bool_t cebec) {this->fCalculateEbECumulants = cebec;};
   Bool_t GetCalculateEbECumulants() const {return this->fCalculateEbECumulants;};
 
   //  5.5.) Weights: 
@@ -198,11 +198,11 @@ class AliFlowAnalysisWithMultiparticleCorrelations{
   TList* GetNestedLoopsList() const {return this->fNestedLoopsList;} 
   void SetNestedLoopsFlagsPro(TProfile* const nlfp) {this->fNestedLoopsFlagsPro = nlfp;};
   TProfile* GetNestedLoopsFlagsPro() const {return this->fNestedLoopsFlagsPro;}; 
-  void SetCrossCheckWithNestedLoops(Bool_t const ccwnl) {this->fCrossCheckWithNestedLoops = ccwnl;};
+  void SetCrossCheckWithNestedLoops(Bool_t ccwnl) {this->fCrossCheckWithNestedLoops = ccwnl;};
   Bool_t GetCrossCheckWithNestedLoops() const {return this->fCrossCheckWithNestedLoops;};
-  void SetCrossCheckDiffWithNestedLoops(Bool_t const ccdwnl) {this->fCrossCheckDiffWithNestedLoops = ccdwnl;};
+  void SetCrossCheckDiffWithNestedLoops(Bool_t ccdwnl) {this->fCrossCheckDiffWithNestedLoops = ccdwnl;};
   Bool_t GetCrossCheckDiffWithNestedLoops() const {return this->fCrossCheckDiffWithNestedLoops;};
-  void SetCrossCheckDiffCSCOBN(Int_t const cs, Int_t const co, Int_t const bn)  
+  void SetCrossCheckDiffCSCOBN(Int_t cs, Int_t co, Int_t bn)  
   {
    this->fCrossCheckDiffCSCOBN[0] = cs; // cos/sin
    this->fCrossCheckDiffCSCOBN[1] = co; // correlator order [1p,2p,3p,4p]
@@ -214,9 +214,9 @@ class AliFlowAnalysisWithMultiparticleCorrelations{
   TList* GetStandardCandlesList() const {return this->fStandardCandlesList;} 
   void SetStandardCandlesFlagsPro(TProfile* const scfp) {this->fStandardCandlesFlagsPro = scfp;};
   TProfile* GetStandardCandlesFlagsPro() const {return this->fStandardCandlesFlagsPro;}; 
-  void SetCalculateStandardCandles(Bool_t const csc) {this->fCalculateStandardCandles = csc;};
+  void SetCalculateStandardCandles(Bool_t csc) {this->fCalculateStandardCandles = csc;};
   Bool_t GetCalculateStandardCandles() const {return this->fCalculateStandardCandles;};
-  void SetPropagateErrorSC(Bool_t const pesc) {this->fPropagateErrorSC = pesc;};
+  void SetPropagateErrorSC(Bool_t pesc) {this->fPropagateErrorSC = pesc;};
   Bool_t GetPropagateErrorSC() const {return this->fPropagateErrorSC;};
   void SetStandardCandlesHist(TH1D* const sch) {this->fStandardCandlesHist = sch;};
   TH1D* GetStandardCandlesHist() const {return this->fStandardCandlesHist;}; 
@@ -228,11 +228,11 @@ class AliFlowAnalysisWithMultiparticleCorrelations{
   TList* GetQcumulantsList() const {return this->fQcumulantsList;} 
   void SetQcumulantsFlagsPro(TProfile* const qcfp) {this->fQcumulantsFlagsPro = qcfp;};
   TProfile* GetQcumulantsFlagsPro() const {return this->fQcumulantsFlagsPro;}; 
-  void SetCalculateQcumulants(Bool_t const cqc) {this->fCalculateQcumulants = cqc;};
+  void SetCalculateQcumulants(Bool_t cqc) {this->fCalculateQcumulants = cqc;};
   Bool_t GetCalculateQcumulants() const {return this->fCalculateQcumulants;};
-  void SetHarmonicQC(Int_t const hqc) {this->fHarmonicQC = hqc;};
+  void SetHarmonicQC(Int_t hqc) {this->fHarmonicQC = hqc;};
   Int_t GetHarmonicQC() const {return this->fHarmonicQC;};
-  void SetPropagateErrorQC(Bool_t const peqc) {this->fPropagateErrorQC = peqc;};
+  void SetPropagateErrorQC(Bool_t peqc) {this->fPropagateErrorQC = peqc;};
   Bool_t GetPropagateErrorQC() const {return this->fPropagateErrorQC;};
   void SetQcumulantsHist(TH1D* const qch) {this->fQcumulantsHist = qch;};
   TH1D* GetQcumulantsHist() const {return this->fQcumulantsHist;}; 
@@ -246,18 +246,18 @@ class AliFlowAnalysisWithMultiparticleCorrelations{
   TList* GetDiffCorrelationsList() const {return this->fDiffCorrelationsList;} 
   void SetDiffCorrelationsFlagsPro(TProfile* const cdfp) {this->fDiffCorrelationsFlagsPro = cdfp;};
   TProfile* GetDiffCorrelationsFlagsPro() const {return this->fDiffCorrelationsFlagsPro;}; 
-  void SetCalculateDiffCorrelations(Bool_t const cdc) {this->fCalculateDiffCorrelations = cdc;};
+  void SetCalculateDiffCorrelations(Bool_t cdc) {this->fCalculateDiffCorrelations = cdc;};
   Bool_t GetCalculateDiffCorrelations() const {return this->fCalculateDiffCorrelations;};
   void SetDiffHarmonics(Int_t order, Int_t *harmonics); // see implementation in .cxx file 
-  void SetCalculateDiffCos(Bool_t const cdc) {this->fCalculateDiffCos = cdc;};
+  void SetCalculateDiffCos(Bool_t cdc) {this->fCalculateDiffCos = cdc;};
   Bool_t GetCalculateDiffCos() const {return this->fCalculateDiffCos;};
-  void SetCalculateDiffSin(Bool_t const cds) {this->fCalculateDiffSin = cds;};
+  void SetCalculateDiffSin(Bool_t cds) {this->fCalculateDiffSin = cds;};
   Bool_t GetCalculateDiffSin() const {return this->fCalculateDiffSin;};
-  void SetCalculateDiffCorrelationsVsPt(Bool_t const cdcvspt) {this->fCalculateDiffCorrelationsVsPt = cdcvspt;};
+  void SetCalculateDiffCorrelationsVsPt(Bool_t cdcvspt) {this->fCalculateDiffCorrelationsVsPt = cdcvspt;};
   Bool_t GetCalculateDiffCorrelationsVsPt() const {return this->fCalculateDiffCorrelationsVsPt;};
-  void SetUseDefaultBinning(Bool_t const udb) {this->fUseDefaultBinning = udb;};
+  void SetUseDefaultBinning(Bool_t udb) {this->fUseDefaultBinning = udb;};
   Bool_t GetUseDefaultBinning() const {return this->fUseDefaultBinning;};
-  void SetnDiffBins(Int_t const ndb) {this->fnDiffBins = ndb;};
+  void SetnDiffBins(Int_t ndb) {this->fnDiffBins = ndb;};
   Int_t GetnDiffBins() const {return this->fnDiffBins;};
   void SetRangesDiffBins(Double_t* const rdb) {this->fRangesDiffBins = rdb;};
   Double_t* GetRangesDiffBins() const {return this->fRangesDiffBins;};
index 6657b81..6161b97 100644 (file)
@@ -445,11 +445,11 @@ void AliAnalysisTaskMultiparticleCorrelations::SetWeightsHist(TH1D* const hist,
 
 //================================================================================================================
 
-void AliAnalysisTaskMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)
+void AliAnalysisTaskMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)
 {
  // Set number of bins for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)";
+ TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -472,15 +472,15 @@ void AliAnalysisTaskMultiparticleCorrelations::SetnBins(const char *type, const
 
  fnBins[rp][ppe] = nBins;
 
-} // void AliAnalysisTaskMultiparticleCorrelations::SetnBins(const char *type, const char *variable, const Int_t nBins)
+} // void AliAnalysisTaskMultiparticleCorrelations::SetnBins(const char *type, const char *variable, Int_t nBins)
 
 //=======================================================================================================================
 
-void AliAnalysisTaskMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)
+void AliAnalysisTaskMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)
 {
  // Set min bin range for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)";
+ TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -503,15 +503,15 @@ void AliAnalysisTaskMultiparticleCorrelations::SetMin(const char *type, const ch
 
  fMin[rp][ppe] = min;
 
-} // void AliAnalysisTaskMultiparticleCorrelations::SetMin(const char *type, const char *variable, const Double_t min)
+} // void AliAnalysisTaskMultiparticleCorrelations::SetMin(const char *type, const char *variable, Double_t min)
 
 //=======================================================================================================================
 
-void AliAnalysisTaskMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t max)
+void AliAnalysisTaskMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t max)
 {
  // Set max bin range for histograms fKinematicsHist[2][3].
 
- TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t max)";
+ TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t max)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI")))
@@ -534,15 +534,15 @@ void AliAnalysisTaskMultiparticleCorrelations::SetMax(const char *type, const ch
 
  fMax[rp][ppe] = max;
 
-} // void AliAnalysisTaskMultiparticleCorrelations::SetMax(const char *type, const char *variable, const Double_t min)
+} // void AliAnalysisTaskMultiparticleCorrelations::SetMax(const char *type, const char *variable, Double_t min)
 
 //=======================================================================================================================
 
-void AliAnalysisTaskMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)
+void AliAnalysisTaskMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)
 {
  // Set number of bins for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)";
+ TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -557,15 +557,15 @@ void AliAnalysisTaskMultiparticleCorrelations::SetnBinsMult(const char *type, co
 
  fnBinsMult[rpr] = nBinsMult;
 
-} // void AliAnalysisTaskMultiparticleCorrelations::SetnBinsMult(const char *type, const Int_t nBinsMult)
+} // void AliAnalysisTaskMultiparticleCorrelations::SetnBinsMult(const char *type, Int_t nBinsMult)
 
 //=======================================================================================================================
 
-void AliAnalysisTaskMultiparticleCorrelations::SetMinMult(const char *type, const Double_t minMult)
+void AliAnalysisTaskMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)
 {
  // Set min bin range for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetMinMult(const char *type, const Double_t minMult)";
+ TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -580,15 +580,15 @@ void AliAnalysisTaskMultiparticleCorrelations::SetMinMult(const char *type, cons
 
  fMinMult[rpr] = minMult;
 
-} // void AliAnalysisTaskMultiparticleCorrelations::SetMinMult(const char *type const Double_t minMult)
+} // void AliAnalysisTaskMultiparticleCorrelations::SetMinMult(const char *type, Double_t minMult)
 
 //=======================================================================================================================
 
-void AliAnalysisTaskMultiparticleCorrelations::SetMaxMult(const char *type, const Double_t maxMult)
+void AliAnalysisTaskMultiparticleCorrelations::SetMaxMult(const char *type, Double_t maxMult)
 {
  // Set max bin range for histograms fMultDistributionsHist[3].
 
- TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetMaxMult(const char *type, const Double_t maxMult)";
+ TString sMethodName = "void AliAnalysisTaskMultiparticleCorrelations::SetMaxMult(const char *type, Double_t maxMult)";
  
  // Basic protection:
  if(!(TString(type).EqualTo("RP") || TString(type).EqualTo("POI") || TString(type).EqualTo("REF")))
@@ -603,7 +603,7 @@ void AliAnalysisTaskMultiparticleCorrelations::SetMaxMult(const char *type, cons
 
  fMaxMult[rpr] = maxMult;
 
-} // void AliAnalysisTaskMultiparticleCorrelations::SetMaxMult(const char *type, const Double_t minMult)
+} // void AliAnalysisTaskMultiparticleCorrelations::SetMaxMult(const char *type, Double_t minMult)
 
 //=======================================================================================================================
 
index bf8bd2c..3f218f5 100644 (file)
@@ -32,24 +32,24 @@ class AliAnalysisTaskMultiparticleCorrelations : public AliAnalysisTaskSE{
   virtual void Terminate(Option_t *);
   
   // Internal flags:
-  void SetMinNoRPs(Int_t const min) {fUseInternalFlags = kTRUE; this->fMinNoRPs = min;};
+  void SetMinNoRPs(Int_t min) {fUseInternalFlags = kTRUE; this->fMinNoRPs = min;};
   Int_t GetMinNoRPs() const {return this->fMinNoRPs;};
-  void SetMaxNoRPs(Int_t const max) {fUseInternalFlags = kTRUE; this->fMaxNoRPs = max;};
+  void SetMaxNoRPs(Int_t max) {fUseInternalFlags = kTRUE; this->fMaxNoRPs = max;};
   Int_t GetMaxNoRPs() const {return this->fMaxNoRPs;};
-  void SetExactNoRPs(Int_t const exact) {fUseInternalFlags = kTRUE; this->fExactNoRPs = exact;};
+  void SetExactNoRPs(Int_t exact) {fUseInternalFlags = kTRUE; this->fExactNoRPs = exact;};
   Int_t GetExactNoRPs() const {return this->fExactNoRPs;};
   void SetAnalysisTag(const char *at) {this->fAnalysisTag = TString(at);};
   TString GetAnalysisTag() const {return this->fAnalysisTag;};
-  void SetDumpThePoints(Bool_t const dtp, Int_t const max) {this->fDumpThePoints = dtp; this->fMaxNoEventsPerFile = max;};
+  void SetDumpThePoints(Bool_t dtp, Int_t max) {this->fDumpThePoints = dtp; this->fMaxNoEventsPerFile = max;};
 
   // Control histograms:
-  void SetFillControlHistograms(Bool_t const fch) {this->fFillControlHistograms = fch;};
+  void SetFillControlHistograms(Bool_t fch) {this->fFillControlHistograms = fch;};
   Bool_t GetFillControlHistograms() const {return this->fFillControlHistograms;};
-  void SetFillKinematicsHist(Bool_t const fkh) {this->fFillKinematicsHist = fkh;};
+  void SetFillKinematicsHist(Bool_t fkh) {this->fFillKinematicsHist = fkh;};
   Bool_t GetFillKinematicsHist() const {return this->fFillKinematicsHist;};
-  void SetFillMultDistributionsHist(Bool_t const mdh) {this->fFillMultDistributionsHist = mdh;};
+  void SetFillMultDistributionsHist(Bool_t mdh) {this->fFillMultDistributionsHist = mdh;};
   Bool_t GetFillMultDistributionsHist() const {return this->fFillMultDistributionsHist;};
-  void SetFillMultCorrelationsHist(Bool_t const mch) {this->fFillMultCorrelationsHist = mch;};
+  void SetFillMultCorrelationsHist(Bool_t mch) {this->fFillMultCorrelationsHist = mch;};
   Bool_t GetFillMultCorrelationsHist() const {return this->fFillMultCorrelationsHist;};
   void SetDontFill(const char *type) 
   {
@@ -58,17 +58,17 @@ class AliAnalysisTaskMultiparticleCorrelations : public AliAnalysisTaskSE{
    else if(TString(type).EqualTo("REF")){this->fDontFill[2] = kTRUE;} 
    else{Fatal("void SetDontFill(const char *type)","type = %s ???? Allowed: RP, POI and REF.",type);}
   }; // void SetDontFill(const char *type)
-  void SetnBins(const char *type, const char *variable, const Int_t nBins); // .cxx
-  void SetMin(const char *type, const char *variable, const Double_t min); // .cxx
-  void SetMax(const char *type, const char *variable, const Double_t max); // .cxx
-  void SetnBinsMult(const char *type, const Int_t nBinsMult); // .cxx
-  void SetMinMult(const char *type, const Double_t minMult); // .cxx
-  void SetMaxMult(const char *type, const Double_t maxMult); // .cxx
+  void SetnBins(const char *type, const char *variable, Int_t nBins); // .cxx
+  void SetMin(const char *type, const char *variable, Double_t min); // .cxx
+  void SetMax(const char *type, const char *variable, Double_t max); // .cxx
+  void SetnBinsMult(const char *type, Int_t nBinsMult); // .cxx
+  void SetMinMult(const char *type, Double_t minMult); // .cxx
+  void SetMaxMult(const char *type, Double_t maxMult); // .cxx
 
   // Q-vectors:
-  void SetCalculateQvector(Bool_t const cqv) {this->fCalculateQvector = cqv;};
+  void SetCalculateQvector(Bool_t cqv) {this->fCalculateQvector = cqv;};
   Bool_t GetCalculateQvector() const {return this->fCalculateQvector;};
-  void SetCalculateDiffQvectors(Bool_t const cdqv) {this->fCalculateDiffQvectors = cdqv;};
+  void SetCalculateDiffQvectors(Bool_t cdqv) {this->fCalculateDiffQvectors = cdqv;};
   Bool_t GetCalculateDiffQvectors() const {return this->fCalculateDiffQvectors;};
 
   // Weights:              
@@ -80,39 +80,39 @@ class AliAnalysisTaskMultiparticleCorrelations : public AliAnalysisTaskSE{
   };
 
   // Correlations:
-  void SetCalculateCorrelations(Bool_t const cc) {this->fCalculateCorrelations = cc;};
+  void SetCalculateCorrelations(Bool_t cc) {this->fCalculateCorrelations = cc;};
   Bool_t GetCalculateCorrelations() const {return this->fCalculateCorrelations;};
-  void SetCalculateIsotropic(Bool_t const ci) {this->fCalculateIsotropic = ci;};
+  void SetCalculateIsotropic(Bool_t ci) {this->fCalculateIsotropic = ci;};
   Bool_t GetCalculateIsotropic() const {return this->fCalculateIsotropic;};
-  void SetCalculateSame(Bool_t const csh) {this->fCalculateSame = csh;};
+  void SetCalculateSame(Bool_t csh) {this->fCalculateSame = csh;};
   Bool_t GetCalculateSame() const {return this->fCalculateSame;};
-  void SetSkipZeroHarmonics(Bool_t const szh) {this->fSkipZeroHarmonics = szh;};
+  void SetSkipZeroHarmonics(Bool_t szh) {this->fSkipZeroHarmonics = szh;};
   Bool_t GetSkipZeroHarmonics() const {return this->fSkipZeroHarmonics;};
-  void SetCalculateSameIsotropic(Bool_t const csi) {this->fCalculateSameIsotropic = csi;};
+  void SetCalculateSameIsotropic(Bool_t csi) {this->fCalculateSameIsotropic = csi;};
   Bool_t GetCalculateSameIsotropic() const {return this->fCalculateSameIsotropic;};
-  void SetCalculateAll(Bool_t const ca) {this->fCalculateAll = ca;};
+  void SetCalculateAll(Bool_t ca) {this->fCalculateAll = ca;};
   Bool_t GetCalculateAll() const {return this->fCalculateAll;};
-  void SetDontGoBeyond(Int_t const dgb) {this->fDontGoBeyond = dgb;};
+  void SetDontGoBeyond(Int_t dgb) {this->fDontGoBeyond = dgb;};
   Int_t GetDontGoBeyond() const {return this->fDontGoBeyond;};
-  void SetCalculateOnlyForHarmonicQC(Bool_t const cofhqc) {this->fCalculateOnlyForHarmonicQC = cofhqc;};
+  void SetCalculateOnlyForHarmonicQC(Bool_t cofhqc) {this->fCalculateOnlyForHarmonicQC = cofhqc;};
   Bool_t GetCalculateOnlyForHarmonicQC() const {return this->fCalculateOnlyForHarmonicQC;};
-  void SetCalculateOnlyForSC(Bool_t const cofsc) {this->fCalculateOnlyForSC = cofsc;};
+  void SetCalculateOnlyForSC(Bool_t cofsc) {this->fCalculateOnlyForSC = cofsc;};
   Bool_t GetCalculateOnlyForSC() const {return this->fCalculateOnlyForSC;};
-  void SetCalculateOnlyCos(Bool_t const coc) {this->fCalculateOnlyCos = coc;};
+  void SetCalculateOnlyCos(Bool_t coc) {this->fCalculateOnlyCos = coc;};
   Bool_t GetCalculateOnlyCos() const {return this->fCalculateOnlyCos;};
-  void SetCalculateOnlySin(Bool_t const cos) {this->fCalculateOnlySin = cos;};
+  void SetCalculateOnlySin(Bool_t cos) {this->fCalculateOnlySin = cos;};
   Bool_t GetCalculateOnlySin() const {return this->fCalculateOnlySin;};
 
   // Event-by-event cumulants:
-  void SetCalculateEbECumulants(Bool_t const cebec) {this->fCalculateEbECumulants = cebec;};
+  void SetCalculateEbECumulants(Bool_t cebec) {this->fCalculateEbECumulants = cebec;};
   Bool_t GetCalculateEbECumulants() const {return this->fCalculateEbECumulants;};
 
   // Nested loops:
-  void SetCrossCheckWithNestedLoops(Bool_t const ccwnl) {this->fCrossCheckWithNestedLoops = ccwnl;};
+  void SetCrossCheckWithNestedLoops(Bool_t ccwnl) {this->fCrossCheckWithNestedLoops = ccwnl;};
   Bool_t GetCrossCheckWithNestedLoops() const {return this->fCrossCheckWithNestedLoops;};
-  void SetCrossCheckDiffWithNestedLoops(Bool_t const ccdwnl) {this->fCrossCheckDiffWithNestedLoops = ccdwnl;};
+  void SetCrossCheckDiffWithNestedLoops(Bool_t ccdwnl) {this->fCrossCheckDiffWithNestedLoops = ccdwnl;};
   Bool_t GetCrossCheckDiffWithNestedLoops() const {return this->fCrossCheckDiffWithNestedLoops;};
-  void SetCrossCheckDiffCSCOBN(Int_t const cs, Int_t const co, Int_t const bn)  
+  void SetCrossCheckDiffCSCOBN(Int_t cs, Int_t co, Int_t bn)  
   {
    this->fCrossCheckDiffCSCOBN[0] = cs; // cos/sin
    this->fCrossCheckDiffCSCOBN[1] = co; // correlator order [1p,2p,3p,4p]
@@ -120,32 +120,32 @@ class AliAnalysisTaskMultiparticleCorrelations : public AliAnalysisTaskSE{
   };
 
   // 'Standard candles':
-  void SetCalculateStandardCandles(Bool_t const csc) {this->fCalculateStandardCandles = csc;};
+  void SetCalculateStandardCandles(Bool_t csc) {this->fCalculateStandardCandles = csc;};
   Bool_t GetCalculateStandardCandles() const {return this->fCalculateStandardCandles;};
-  void SetPropagateErrorSC(Bool_t const pesc) {this->fPropagateErrorSC = pesc;};
+  void SetPropagateErrorSC(Bool_t pesc) {this->fPropagateErrorSC = pesc;};
   Bool_t GetPropagateErrorSC() const {return this->fPropagateErrorSC;};
 
   // Q-cumulants:
-  void SetCalculateQcumulants(Bool_t const cqc) {this->fCalculateQcumulants = cqc;};
+  void SetCalculateQcumulants(Bool_t cqc) {this->fCalculateQcumulants = cqc;};
   Bool_t GetCalculateQcumulants() const {return this->fCalculateQcumulants;};
-  void SetHarmonicQC(Int_t const hqc) {this->fHarmonicQC = hqc;};
+  void SetHarmonicQC(Int_t hqc) {this->fHarmonicQC = hqc;};
   Int_t GetHarmonicQC() const {return this->fHarmonicQC;};
-  void SetPropagateErrorQC(Bool_t const peqc) {this->fPropagateErrorQC = peqc;};
+  void SetPropagateErrorQC(Bool_t peqc) {this->fPropagateErrorQC = peqc;};
   Bool_t GetPropagateErrorQC() const {return this->fPropagateErrorQC;};
 
   // Differential correlations:
-  void SetCalculateDiffCorrelations(Bool_t const cdc) {this->fCalculateDiffCorrelations = cdc;};
+  void SetCalculateDiffCorrelations(Bool_t cdc) {this->fCalculateDiffCorrelations = cdc;};
   Bool_t GetCalculateDiffCorrelations() const {return this->fCalculateDiffCorrelations;};
   void SetDiffHarmonics(Int_t order, Int_t *harmonics); // see implementation in .cxx file 
-  void SetCalculateDiffCos(Bool_t const cdc) {this->fCalculateDiffCos = cdc;};
+  void SetCalculateDiffCos(Bool_t cdc) {this->fCalculateDiffCos = cdc;};
   Bool_t GetCalculateDiffCos() const {return this->fCalculateDiffCos;};
-  void SetCalculateDiffSin(Bool_t const cds) {this->fCalculateDiffSin = cds;};
+  void SetCalculateDiffSin(Bool_t cds) {this->fCalculateDiffSin = cds;};
   Bool_t GetCalculateDiffSin() const {return this->fCalculateDiffSin;};
-  void SetCalculateDiffCorrelationsVsPt(Bool_t const cdcvspt) {this->fCalculateDiffCorrelationsVsPt = cdcvspt;};
+  void SetCalculateDiffCorrelationsVsPt(Bool_t cdcvspt) {this->fCalculateDiffCorrelationsVsPt = cdcvspt;};
   Bool_t GetCalculateDiffCorrelationsVsPt() const {return this->fCalculateDiffCorrelationsVsPt;};
-  void SetUseDefaultBinning(Bool_t const udb) {this->fUseDefaultBinning = udb;};
+  void SetUseDefaultBinning(Bool_t udb) {this->fUseDefaultBinning = udb;};
   Bool_t GetUseDefaultBinning() const {return this->fUseDefaultBinning;};
-  void SetnDiffBins(Int_t const ndb) {this->fnDiffBins = ndb;};
+  void SetnDiffBins(Int_t ndb) {this->fnDiffBins = ndb;};
   Int_t GetnDiffBins() const {return this->fnDiffBins;};
   void SetRangesDiffBins(Double_t* const rdb) {this->fRangesDiffBins = rdb;};
   Double_t* GetRangesDiffBins() const {return this->fRangesDiffBins;};
index ecee43d..f9bb479 100644 (file)
@@ -39,7 +39,7 @@
 
 ClassImp(AliTwoPlusOneContainer)
 
-AliTwoPlusOneContainer::AliTwoPlusOneContainer(const char* name, const char* binning, const Double_t alpha) : 
+AliTwoPlusOneContainer::AliTwoPlusOneContainer(const char* name, const char* binning, Double_t alpha) : 
   TNamed(name, name),
   fTwoPlusOne(0),
   fTriggerPt1Min(0),
index 76ae4bb..725430e 100644 (file)
@@ -22,7 +22,7 @@ class TH3F;
 class AliTwoPlusOneContainer : public TNamed
 {
  public:
-  AliTwoPlusOneContainer(const char* name = "AliTwoPlusOneContainer", const char* binning = 0, const Double_t alpha = 0.2);
+  AliTwoPlusOneContainer(const char* name = "AliTwoPlusOneContainer", const char* binning = 0, Double_t alpha = 0.2);
 
   virtual ~AliTwoPlusOneContainer();
   
index 500e2b0..226998e 100644 (file)
@@ -288,14 +288,14 @@ AliHFEV0taginfo::AliHFEV0tag::~AliHFEV0tag(){
 
 //Set track ID and particle info 
 //___________________________________________________________________
-void AliHFEV0taginfo::AliHFEV0tag::SetTrack(const Int_t trackID, const AliPID::EParticleType Pinfo){
+void AliHFEV0taginfo::AliHFEV0tag::SetTrack(Int_t trackID, AliPID::EParticleType Pinfo){
     fTrackID = trackID;
     fPinfo = Pinfo;
 }
 
 //Set track ID and production verxtex
 //___________________________________________________________________
-void AliHFEV0taginfo::AliHFEV0tag::SetProdR(const Int_t trackID, const Double_t prodR){
+void AliHFEV0taginfo::AliHFEV0tag::SetProdR(Int_t trackID, Double_t prodR){
     fTrackID = trackID;
     fProdR = prodR;
 }
index 3a4d53d..b3c4e2c 100644 (file)
@@ -59,8 +59,8 @@ class AliHFEV0taginfo: public TNamed{
                 virtual Int_t Compare(const TObject *ref) const;
 
                 //Setter
-                void SetTrack(const Int_t trackID, const AliPID::EParticleType Pinfo); //Set track ID
-                void SetProdR(const Int_t trackID, const Double_t prodR); //Set V0 daughter production vertex radius
+                void SetTrack(Int_t trackID, AliPID::EParticleType Pinfo); //Set track ID
+                void SetProdR(Int_t trackID, Double_t prodR); //Set V0 daughter production vertex radius
                 //Getter
                 Int_t GetTrackID() const { return fTrackID; };
                 AliPID::EParticleType GetPinfo() const { return fPinfo; };
index 449624b..3c37e92 100644 (file)
@@ -259,7 +259,7 @@ void AliHFEmcQA::CreatDefaultHistograms(TList * const qaList)
 }
   
 //__________________________________________
-void AliHFEmcQA::CreateHistograms(const Int_t kquark) 
+void AliHFEmcQA::CreateHistograms(Int_t kquark) 
 {
   // create histograms
 
@@ -642,7 +642,7 @@ void AliHFEmcQA::GetMesonKine()
 
 }
 //__________________________________________
-void AliHFEmcQA::GetQuarkKine(TParticle *part, Int_t iTrack, const Int_t kquark) 
+void AliHFEmcQA::GetQuarkKine(TParticle *part, Int_t iTrack, Int_t kquark) 
 {
   // get heavy quark kinematics
 
@@ -731,7 +731,7 @@ void AliHFEmcQA::GetQuarkKine(TParticle *part, Int_t iTrack, const Int_t kquark)
 }
 
 //__________________________________________
-void AliHFEmcQA::EndOfEventAna(const Int_t kquark)
+void AliHFEmcQA::EndOfEventAna(Int_t kquark)
 {
   // end of event analysis
 
@@ -842,7 +842,7 @@ void AliHFEmcQA::EndOfEventAna(const Int_t kquark)
 }
 
 //__________________________________________
-void AliHFEmcQA::GetHadronKine(TParticle* mcpart, const Int_t kquark)
+void AliHFEmcQA::GetHadronKine(TParticle* mcpart, Int_t kquark)
 {
     // decay electron kinematics
 
@@ -925,7 +925,7 @@ void AliHFEmcQA::GetHadronKine(TParticle* mcpart, const Int_t kquark)
 }
 
 //__________________________________________
-void AliHFEmcQA::GetDecayedKine(TParticle* mcpart, const Int_t kquark, Int_t kdecayed) 
+void AliHFEmcQA::GetDecayedKine(TParticle* mcpart, Int_t kquark, Int_t kdecayed) 
 {
     // decay electron kinematics
     
@@ -1283,7 +1283,7 @@ void AliHFEmcQA::GetDecayedKine(TParticle* mcpart, const Int_t kquark, Int_t kde
 }
 
 //____________________________________________________________________
-void  AliHFEmcQA::GetDecayedKine(AliAODMCParticle *mcpart, const Int_t kquark, Int_t kdecayed)
+void  AliHFEmcQA::GetDecayedKine(AliAODMCParticle *mcpart, Int_t kquark, Int_t kdecayed)
 {
   // decay electron kinematics
 
@@ -1462,7 +1462,7 @@ void AliHFEmcQA::IdentifyMother(Int_t motherlabel, Int_t &motherpdg, Int_t &gran
 }
 
 //__________________________________________
-void AliHFEmcQA::HardScattering(const Int_t kquark, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel)
+void AliHFEmcQA::HardScattering(Int_t kquark, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel)
 {
        // mothertype -1 means this heavy quark coming from hard vertex
 
@@ -2164,7 +2164,7 @@ Int_t AliHFEmcQA::GetElecSource(const AliAODMCParticle * const mcpart) const
   return origin;
 }
 //__________________________________________
-Double_t AliHFEmcQA::GetWeightFactor(AliMCParticle *mctrack, const Int_t iBgLevel){
+Double_t AliHFEmcQA::GetWeightFactor(AliMCParticle *mctrack, Int_t iBgLevel){
   //
   // Get weighting factor for the realistic background estimation, for three possible background yield levels, indicated by the argument "iLevel": the best estimate (0), the lower uncertainty level (1), and the upper uncertainty level (2)
   //
@@ -2353,7 +2353,7 @@ Double_t AliHFEmcQA::GetWeightFactor(AliMCParticle *mctrack, const Int_t iBgLeve
 }
 
 //__________________________________________
-Double_t AliHFEmcQA::GetWeightFactor(const AliAODMCParticle * const mcpart, const Int_t iBgLevel){
+Double_t AliHFEmcQA::GetWeightFactor(const AliAODMCParticle * const mcpart, Int_t iBgLevel){
   //
   // Get weighting factor for the realistic background estimation, for three possible background yield levels, indicated by the argument "iLevel": the best estimate (0), the lower uncertainty level (1), and the upper uncertainty level (2)
   //
@@ -2444,7 +2444,7 @@ Int_t AliHFEmcQA::GetMother(const AliVParticle * const mcpart) const {
   return label;
 }
 //__________________________________________
-Int_t AliHFEmcQA::GetWeightCentralityBin(const Float_t percentile) const {
+Int_t AliHFEmcQA::GetWeightCentralityBin(Float_t percentile) const {
   //
   //translate the centrality percentile into the centrality bin of the reference weighting histograms for electron background
   //
index c492791..d978708 100644 (file)
@@ -69,26 +69,26 @@ class AliHFEmcQA: public TObject {
     TList *GetList() const { return fQAhistos; };
     void PostAnalyze() const;
     void CreatDefaultHistograms(TList * const qaList); // create default histograms  
-    void CreateHistograms(const Int_t kquark); // create histograms for mc qa analysis
+    void CreateHistograms(Int_t kquark); // create histograms for mc qa analysis
     void SetMCEvent(AliMCEvent* const mcEvent){fMCEvent = mcEvent;} 
     void SetGenEventHeader(AliGenEventHeader* const mcHeader){fMCHeader=mcHeader;} // set stack pointer
     void SetMCArray(TClonesArray* const mcarry){fMCArray=mcarry;} // set mcarray pointer
     void Init();
 
-    void GetQuarkKine(TParticle *part, Int_t iTrack, const Int_t kquark); // get heavy quark kinematics distribution
-    void GetHadronKine(TParticle *part, const Int_t kquark); // get heavy hadron kinematics distribution
-    void GetDecayedKine(TParticle *part, const Int_t kquark, const Int_t kdecayed); // get decay electron kinematics distribution
-    void GetDecayedKine(AliAODMCParticle *mcpart, const Int_t kquark, Int_t kdecayed); // get decay electron kinematics for AOD 
+    void GetQuarkKine(TParticle *part, Int_t iTrack, Int_t kquark); // get heavy quark kinematics distribution
+    void GetHadronKine(TParticle *part, Int_t kquark); // get heavy hadron kinematics distribution
+    void GetDecayedKine(TParticle *part, Int_t kquark, Int_t kdecayed); // get decay electron kinematics distribution
+    void GetDecayedKine(AliAODMCParticle *mcpart, Int_t kquark, Int_t kdecayed); // get decay electron kinematics for AOD 
     void GetMesonKine(); // get meson and its decay electron pt spectra
-    void EndOfEventAna(const Int_t kquark); // run analysis which should be done at the end of the event loop
+    void EndOfEventAna(Int_t kquark); // run analysis which should be done at the end of the event loop
     Int_t GetSource(const TParticle * const mcpart) const; // return source id 
     Int_t GetElecSource(const AliVParticle * const mctrack) const;
     Int_t GetElecSource(TParticle * const mcpart) const; // return electron source id 
     Int_t GetElecSource(const AliAODMCParticle * const mcpart) const;
     Int_t GetSource(const AliVParticle * const mcpart) const; // return electron source id for AOD
-    Double_t GetWeightFactor(AliMCParticle *mctrack, const Int_t iBgLevel); // return best/lower/upper weighting factor for electron's mother meson
-    Double_t GetWeightFactor(const AliAODMCParticle * const mcpart, const Int_t iBgLevel);
-    Int_t GetWeightCentralityBin(const Float_t percentile) const; //translate the centrality percentile into the centrality bin of the reference weighting histograms for electron background
+    Double_t GetWeightFactor(AliMCParticle *mctrack, Int_t iBgLevel); // return best/lower/upper weighting factor for electron's mother meson
+    Double_t GetWeightFactor(const AliAODMCParticle * const mcpart, Int_t iBgLevel);
+    Int_t GetWeightCentralityBin(Float_t percentile) const; //translate the centrality percentile into the centrality bin of the reference weighting histograms for electron background
     void EnableDebugStreamer() { fIsDebugStreamerON = kTRUE;};
 
     void SetBackgroundWeightFactor(Double_t *elecBackgroundFactor, Double_t *binLimit);
@@ -109,7 +109,7 @@ class AliHFEmcQA: public TObject {
   protected:
     Int_t GetMother(const AliVParticle * const track) const;
     void IdentifyMother(Int_t motherlabel, Int_t &motherpdg, Int_t &grandmotherlabel); // 
-    void HardScattering(const Int_t kquark, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from hard scattering
+    void HardScattering(Int_t kquark, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from hard scattering
     void ReportStrangeness(Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // report if the quark production process is unknown
     Bool_t IsFromInitialShower(Int_t inputmotherlabel, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from initial parton shower 
     Bool_t IsFromFinalParton(Int_t inputmotherlabel, Int_t &motherID, Int_t &mothertype, Int_t &motherlabel); // check if the quark is produced from final parton shower
index 2ba1b2a..c9f1258 100644 (file)
@@ -175,7 +175,7 @@ AliTPCCorrection::~AliTPCCorrection() {
   //
 }
 
-void AliTPCCorrection::CorrectPoint(Float_t x[],const Short_t roc) {
+void AliTPCCorrection::CorrectPoint(Float_t x[], Short_t roc) {
   //
   // Corrects the initial coordinates x (cartesian coordinates)
   // according to the given effect (inherited classes)
@@ -186,7 +186,7 @@ void AliTPCCorrection::CorrectPoint(Float_t x[],const Short_t roc) {
   for (Int_t j=0;j<3;++j) x[j]+=dx[j];
 }
 
-void AliTPCCorrection::CorrectPoint(const Float_t x[],const Short_t roc,Float_t xp[]) {
+void AliTPCCorrection::CorrectPoint(const Float_t x[], Short_t roc,Float_t xp[]) {
   //
   // Corrects the initial coordinates x (cartesian coordinates) and stores the new 
   // (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
@@ -197,7 +197,7 @@ void AliTPCCorrection::CorrectPoint(const Float_t x[],const Short_t roc,Float_t
   for (Int_t j=0;j<3;++j) xp[j]=x[j]+dx[j];
 }
 
-void AliTPCCorrection::DistortPoint(Float_t x[],const Short_t roc) {
+void AliTPCCorrection::DistortPoint(Float_t x[], Short_t roc) {
   //
   // Distorts the initial coordinates x (cartesian coordinates)
   // according to the given effect (inherited classes)
@@ -208,7 +208,7 @@ void AliTPCCorrection::DistortPoint(Float_t x[],const Short_t roc) {
   for (Int_t j=0;j<3;++j) x[j]+=dx[j];
 }
 
-void AliTPCCorrection::DistortPointLocal(Float_t x[],const Short_t roc) {
+void AliTPCCorrection::DistortPointLocal(Float_t x[], Short_t roc) {
   //
   // Distorts the initial coordinates x (cartesian coordinates)
   // according to the given effect (inherited classes)
@@ -225,7 +225,7 @@ void AliTPCCorrection::DistortPointLocal(Float_t x[],const Short_t roc) {
   x[1]= +sa*gxyz[0]+ca*gxyz[1];
   x[2]= gxyz[2];
 }
-void AliTPCCorrection::CorrectPointLocal(Float_t x[],const Short_t roc) {
+void AliTPCCorrection::CorrectPointLocal(Float_t x[], Short_t roc) {
   //
   // Distorts the initial coordinates x (cartesian coordinates)
   // according to the given effect (inherited classes)
@@ -243,7 +243,7 @@ void AliTPCCorrection::CorrectPointLocal(Float_t x[],const Short_t roc) {
   x[2]=  gxyz[2];
 }
 
-void AliTPCCorrection::DistortPoint(const Float_t x[],const Short_t roc,Float_t xp[]) {
+void AliTPCCorrection::DistortPoint(const Float_t x[], Short_t roc,Float_t xp[]) {
   //
   // Distorts the initial coordinates x (cartesian coordinates) and stores the new 
   // (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
@@ -254,7 +254,7 @@ void AliTPCCorrection::DistortPoint(const Float_t x[],const Short_t roc,Float_t
   for (Int_t j=0;j<3;++j) xp[j]=x[j]+dx[j];
 }
 
-void AliTPCCorrection::GetCorrection(const Float_t /*x*/[],const Short_t /*roc*/,Float_t dx[]) {
+void AliTPCCorrection::GetCorrection(const Float_t /*x*/[], Short_t /*roc*/,Float_t dx[]) {
   //
   // This function delivers the correction values dx in respect to the inital coordinates x
   // roc represents the TPC read out chamber (offline numbering convention)
@@ -263,7 +263,7 @@ void AliTPCCorrection::GetCorrection(const Float_t /*x*/[],const Short_t /*roc*/
   for (Int_t j=0;j<3;++j) { dx[j]=0.; }
 }
 
-void AliTPCCorrection::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
+void AliTPCCorrection::GetDistortion(const Float_t x[], Short_t roc,Float_t dx[]) {
   //
   // This function delivers the distortion values dx in respect to the inital coordinates x
   // roc represents the TPC read out chamber (offline numbering convention)
@@ -272,7 +272,7 @@ void AliTPCCorrection::GetDistortion(const Float_t x[],const Short_t roc,Float_t
   for (Int_t j=0;j<3;++j) dx[j]=-dx[j];
 }
 
-void AliTPCCorrection::GetCorrectionDz(const Float_t x[],const Short_t roc,Float_t dx[], Float_t delta) {
+void AliTPCCorrection::GetCorrectionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta) {
   // author: marian.ivanov@cern.ch
   //
   // In this (virtual)function calculates the dx'/dz,  dy'/dz  and dz'/dz at given point (x,y,z)
@@ -351,7 +351,7 @@ void AliTPCCorrection::GetCorrectionDz(const Float_t x[],const Short_t roc,Float
   dx[2] = fitz.GetParameter(1);
 }
 
-void AliTPCCorrection::GetDistortionDz(const Float_t x[],const Short_t roc,Float_t dx[], Float_t delta) {
+void AliTPCCorrection::GetDistortionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta) {
   // author: marian.ivanov@cern.ch
   //
   // In this (virtual)function calculates the dx'/dz,  dy'/dz  and dz'/dz at given point (x,y,z)
@@ -416,7 +416,7 @@ void AliTPCCorrection::GetDistortionDz(const Float_t x[],const Short_t roc,Float
     dx[2] = fitz.GetParameter(1);
 }
 
-void AliTPCCorrection::GetCorrectionIntegralDz(const Float_t x[],const Short_t roc,Float_t dx[], Float_t delta){
+void AliTPCCorrection::GetCorrectionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta){
   //
   // Integrate 3D distortion along drift lines starting from the roc plane
   //   to the expected z position of the point, this assumes that dz is small
@@ -468,7 +468,7 @@ void AliTPCCorrection::GetCorrectionIntegralDz(const Float_t x[],const Short_t r
   dx[2]=      sumdz; //TODO: is sumdz correct?
 }
 
-void AliTPCCorrection::GetDistortionIntegralDz(const Float_t x[],const Short_t roc,Float_t dx[], Float_t delta){
+void AliTPCCorrection::GetDistortionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta){
   //
   // Integrate 3D distortion along drift lines
   // To define the drift lines virtual function  AliTPCCorrection::GetCorrectionDz is used
@@ -763,7 +763,7 @@ TH2F* AliTPCCorrection::CreateTH2F(const char *name,const char *title,
 
 // Simple Interpolation functions: e.g. with bi(tri)cubic interpolations (not yet in TH2 and TH3)
 
-void AliTPCCorrection::Interpolate2DEdistortion( const Int_t order, const Double_t r, const Double_t z, 
+void AliTPCCorrection::Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z, 
                                                  const Double_t er[kNZ][kNR], Double_t &erValue ) {
   //
   // Interpolate table - 2D interpolation
@@ -784,7 +784,7 @@ void AliTPCCorrection::Interpolate2DEdistortion( const Int_t order, const Double
 
 }
 
-void AliTPCCorrection::Interpolate3DEdistortion( const Int_t order, const Double_t r, const Float_t phi, const Double_t z, 
+void AliTPCCorrection::Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z, 
                                                 const Double_t er[kNZ][kNPhi][kNR], const Double_t ephi[kNZ][kNPhi][kNR], const Double_t ez[kNZ][kNPhi][kNR],
                                                 Double_t &erValue, Double_t &ephiValue, Double_t &ezValue) {
   //
@@ -828,8 +828,8 @@ void AliTPCCorrection::Interpolate3DEdistortion( const Int_t order, const Double
 
 }
 
-Double_t AliTPCCorrection::Interpolate2DTable( const Int_t order, const Double_t x, const Double_t y, 
-                                             const Int_t nx,  const Int_t ny, const Double_t xv[], const Double_t yv[], 
+Double_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y, 
+                                             Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[], 
                                              const TMatrixD &array ) {
   //
   // Interpolate table (TMatrix format) - 2D interpolation
@@ -855,8 +855,8 @@ Double_t AliTPCCorrection::Interpolate2DTable( const Int_t order, const Double_t
 
 }
 
-Double_t AliTPCCorrection::Interpolate3DTable( const Int_t order, const Double_t x,   const Double_t y,   const Double_t z,
-                                             const Int_t  nx,    const Int_t  ny,    const Int_t  nz,
+Double_t AliTPCCorrection::Interpolate3DTable( Int_t order, Double_t x,   Double_t y,   Double_t z,
+                                             Int_t  nx,    Int_t  ny,    Int_t  nz,
                                              const Double_t xv[], const Double_t yv[], const Double_t zv[],
                                              TMatrixD **arrayofArrays ) {
   //
@@ -893,7 +893,7 @@ Double_t AliTPCCorrection::Interpolate3DTable( const Int_t order, const Double_t
 }
 
 Double_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Double_t yArray[], 
-                                      const Int_t order, const Double_t x ) {
+                                      Int_t order, Double_t x ) {
   //
   // Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
   //
@@ -911,8 +911,8 @@ Double_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Double_t
 
 }
 
-Float_t AliTPCCorrection::Interpolate2DTable( const Int_t order, const Double_t x, const Double_t y, 
-                                             const Int_t nx,  const Int_t ny, const Double_t xv[], const Double_t yv[], 
+Float_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y, 
+                                             Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[], 
                                              const TMatrixF &array ) {
   //
   // Interpolate table (TMatrix format) - 2D interpolation
@@ -939,8 +939,8 @@ Float_t AliTPCCorrection::Interpolate2DTable( const Int_t order, const Double_t
 
 }
 
-Float_t AliTPCCorrection::Interpolate3DTable( const Int_t order, const Double_t x,   const Double_t y,   const Double_t z,
-                                             const Int_t  nx,    const Int_t  ny,    const Int_t  nz,
+Float_t AliTPCCorrection::Interpolate3DTable( Int_t order, Double_t x,   Double_t y,   Double_t z,
+                                             Int_t  nx,    Int_t  ny,    Int_t  nz,
                                              const Double_t xv[], const Double_t yv[], const Double_t zv[],
                                              TMatrixF **arrayofArrays ) {
   //
@@ -977,7 +977,7 @@ Float_t AliTPCCorrection::Interpolate3DTable( const Int_t order, const Double_t
 
 }
 Float_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Float_t yArray[], 
-                                      const Int_t order, const Double_t x ) {
+                                      Int_t order, Double_t x ) {
   //
   // Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
   // Float version (in order to decrease the OCDB size)
@@ -998,7 +998,7 @@ Float_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Float_t yA
 
 
 
-void AliTPCCorrection::Search( const Int_t n, const Double_t xArray[], const Double_t x, Int_t &low ) {
+void AliTPCCorrection::Search( Int_t n, const Double_t xArray[], Double_t x, Int_t &low ) {
   //
   // Search an ordered table by starting at the most recently used point
   //
@@ -1097,8 +1097,8 @@ void AliTPCCorrection::InitLookUpfulcrums() {
 
 void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity, 
                                           TMatrixD &arrayErOverEz, TMatrixD &arrayDeltaEz, 
-                                          const Int_t rows, const Int_t columns, const Int_t iterations,
-                                          const Bool_t rocDisplacement ) {
+                                          Int_t rows, Int_t columns, Int_t iterations,
+                                          Bool_t rocDisplacement ) {
   //
   // Solve Poisson's Equation by Relaxation Technique in 2D (assuming cylindrical symmetry)
   //
@@ -1334,8 +1334,8 @@ void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDen
 
 void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**arrayofChargeDensities, 
                    TMatrixD**arrayofEroverEz, TMatrixD**arrayofEPhioverEz, TMatrixD**arrayofDeltaEz,
-                   const Int_t rows, const Int_t columns,  const Int_t phislices, 
-                   const Float_t deltaphi, const Int_t iterations, const Int_t symmetry,
+                   Int_t rows, Int_t columns,  Int_t phislices, 
+                   Float_t deltaphi, Int_t iterations, Int_t symmetry,
                    Bool_t rocDisplacement  ) {
   //
   // 3D - Solve Poisson's Equation in 3D by Relaxation Technique
index 348a2d8..5380e76 100644 (file)
@@ -33,22 +33,22 @@ public:
   
 
   // functions to correct a space point
-          void CorrectPoint (      Float_t x[],const Short_t roc);
-          void CorrectPointLocal(Float_t x[],const Short_t roc);
-          void CorrectPoint (const Float_t x[],const Short_t roc,Float_t xp[]);
-         virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
+          void CorrectPoint (      Float_t x[], Short_t roc);
+          void CorrectPointLocal(Float_t x[], Short_t roc);
+          void CorrectPoint (const Float_t x[], Short_t roc,Float_t xp[]);
+         virtual void GetCorrection(const Float_t x[], Short_t roc,Float_t dx[]);
 
-  virtual void GetCorrectionDz(const Float_t x[],const Short_t roc,Float_t dx[], Float_t delta);
-  virtual void GetCorrectionIntegralDz(const Float_t x[],const Short_t roc,Float_t dx[], Float_t delta);
+  virtual void GetCorrectionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
+  virtual void GetCorrectionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
   
   // functions to distort a space point
-          void DistortPoint (      Float_t x[],const Short_t roc);
-          void DistortPointLocal(Float_t x[],const Short_t roc);
-          void DistortPoint (const Float_t x[],const Short_t roc,Float_t xp[]);
-  virtual void GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]);
+          void DistortPoint (      Float_t x[], Short_t roc);
+          void DistortPointLocal(Float_t x[], Short_t roc);
+          void DistortPoint (const Float_t x[], Short_t roc,Float_t xp[]);
+  virtual void GetDistortion(const Float_t x[], Short_t roc,Float_t dx[]);
 
-  virtual void GetDistortionDz(const Float_t x[],const Short_t roc,Float_t dx[], Float_t delta);
-  virtual void GetDistortionIntegralDz(const Float_t x[],const Short_t roc,Float_t dx[], Float_t delta);
+  virtual void GetDistortionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
+  virtual void GetDistortionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
   
   // initialization and update functions
   virtual void Init();
@@ -126,34 +126,34 @@ protected:
   // Simple Interpolation functions: e.g. with tricubic interpolation (not yet in TH3)
   Int_t fILow, fJLow, fKLow;          // variable to help in the interpolation 
   // Double_t versions
-  void Interpolate2DEdistortion( const Int_t order, const Double_t r, const Double_t z, 
+  void Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z, 
                                 const Double_t er[kNZ][kNR], Double_t &erValue );
-  void Interpolate3DEdistortion( const Int_t order, const Double_t r, const Float_t phi, const Double_t z, 
+  void Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z, 
                                 const Double_t er[kNZ][kNPhi][kNR], const Double_t ephi[kNZ][kNPhi][kNR], 
                                 const Double_t ez[kNZ][kNPhi][kNR],
                                 Double_t &erValue, Double_t &ephiValue, Double_t &ezValue);
   // TMatrixD versions (for e.g. Poisson relaxation)
-  Double_t Interpolate2DTable( const Int_t order, const Double_t x, const Double_t y, 
-                             const Int_t nx,  const Int_t ny, const Double_t xv[], const Double_t yv[], 
+  Double_t Interpolate2DTable( Int_t order, Double_t x, Double_t y, 
+                             Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[], 
                              const TMatrixD &array );
-  Double_t Interpolate3DTable( const Int_t order, const Double_t x,   const Double_t y,   const Double_t z,
-                             const Int_t  nx,    const Int_t  ny,    const Int_t  nz,
+  Double_t Interpolate3DTable( Int_t order, Double_t x,   Double_t y,   Double_t z,
+                             Int_t  nx,    Int_t  ny,    Int_t  nz,
                              const Double_t xv[], const Double_t yv[], const Double_t zv[],
                              TMatrixD **arrayofArrays );
   Double_t Interpolate( const Double_t xArray[], const Double_t yArray[], 
-                       const Int_t order, const Double_t x );
-  void Search( const Int_t n, const Double_t xArray[], const Double_t x, Int_t &low );
+                       Int_t order, Double_t x );
+  void Search( Int_t n, const Double_t xArray[], Double_t x, Int_t &low );
  
   // TMatrixF versions (smaller size, e.g. for final look up table)
-  Float_t Interpolate2DTable( const Int_t order, const Double_t x, const Double_t y, 
-                             const Int_t nx,  const Int_t ny, const Double_t xv[], const Double_t yv[], 
+  Float_t Interpolate2DTable( Int_t order, Double_t x, Double_t y, 
+                             Int_t nx,  Int_t ny, const Double_t xv[], const Double_t yv[], 
                              const TMatrixF &array );
-  Float_t Interpolate3DTable( const Int_t order, const Double_t x,   const Double_t y,   const Double_t z,
-                             const Int_t  nx,    const Int_t  ny,    const Int_t  nz,
+  Float_t Interpolate3DTable( Int_t order, Double_t x,   Double_t y,   Double_t z,
+                             Int_t  nx,    Int_t  ny,    Int_t  nz,
                              const Double_t xv[], const Double_t yv[], const Double_t zv[],
                               TMatrixF **arrayofArrays ); 
   Float_t Interpolate( const Double_t xArray[], const Float_t yArray[], 
-                       const Int_t order, const Double_t x );
+                       Int_t order, Double_t x );
 
   virtual Int_t IsPowerOfTwo ( Int_t i ) const  ;
 
@@ -162,14 +162,14 @@ protected:
   // Algorithms to solve the laplace or poisson equation 
   void PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity, 
                           TMatrixD &arrayErOverEz, TMatrixD &arrayDeltaEz,
-                          const Int_t rows, const Int_t columns, const Int_t iterations,
-                          const Bool_t rocDisplacement = kTRUE);
+                          Int_t rows, Int_t columns, Int_t iterations,
+                          Bool_t rocDisplacement = kTRUE);
 
   void PoissonRelaxation3D( TMatrixD **arrayofArrayV, TMatrixD **arrayofChargeDensities, 
                            TMatrixD **arrayofEroverEz, TMatrixD **arrayofEPhioverEz, TMatrixD **arrayofEz,
-                           const Int_t rows, const Int_t columns,  const Int_t phislices, 
-                           const Float_t deltaphi, const Int_t iterations, const Int_t summetry,
-                           const Bool_t rocDisplacement = kTRUE); 
+                           Int_t rows, Int_t columns,  Int_t phislices, 
+                           Float_t deltaphi, Int_t iterations, Int_t summetry,
+                           Bool_t rocDisplacement = kTRUE); 
   void   SetIsLocal(Bool_t isLocal){fIsLocal=isLocal;}
   Bool_t IsLocal() const  { return fIsLocal;}
 protected:
index 2613004..756281d 100644 (file)
@@ -1645,7 +1645,7 @@ void  AliTPCtracker::ApplyTailCancellation(){
   }// end of side loop
 }
 //_____________________________________________________________________________
-void AliTPCtracker::GetTailValue(const Float_t ampfactor,Double_t &ionTailMax, Double_t &ionTailTotal,TGraphErrors **graphRes,Float_t *indexAmpGraphs,AliTPCclusterMI *cl0,AliTPCclusterMI *cl1){
+void AliTPCtracker::GetTailValue(Float_t ampfactor,Double_t &ionTailMax, Double_t &ionTailTotal,TGraphErrors **graphRes,Float_t *indexAmpGraphs,AliTPCclusterMI *cl0,AliTPCclusterMI *cl1){
 
   //
   // Function in order to calculate the amount of the correction to be added for a given cluster, return values are ionTailTaoltal and ionTailMax
index 6239fbf..5a9d265 100644 (file)
@@ -58,7 +58,7 @@ public:
   virtual void FillClusterArray(TObjArray* array) const;
   void   Transform(AliTPCclusterMI * cluster);
   void ApplyTailCancellation();
-  void GetTailValue(const Float_t ampfactor,Double_t &ionTailMax,Double_t &ionTailTotal,TGraphErrors **graphRes,Float_t *indexAmpGraphs,AliTPCclusterMI *cl0,AliTPCclusterMI *cl1);
+  void GetTailValue(Float_t ampfactor,Double_t &ionTailMax,Double_t &ionTailTotal,TGraphErrors **graphRes,Float_t *indexAmpGraphs,AliTPCclusterMI *cl0,AliTPCclusterMI *cl1);
   //
   void FillESD(const TObjArray* arr);
   void DeleteSeeds();
index 8123181..e6d555f 100644 (file)
@@ -167,7 +167,7 @@ AliToyMCEvent* AliToyMCEventGeneratorSimple::Generate(Double_t time)
 }
 
 //________________________________________________________________
-void AliToyMCEventGeneratorSimple::RunSimulation(const Int_t nevents/*=10*/, const Int_t ntracks/*=400*/, const Int_t rate/*=50*/)
+void AliToyMCEventGeneratorSimple::RunSimulation(Int_t nevents/*=10*/, Int_t ntracks/*=400*/, Int_t rate/*=50*/)
 {
   //
   // run simple simulation with equal event spacing
@@ -203,7 +203,7 @@ void AliToyMCEventGeneratorSimple::RunSimulation(const Int_t nevents/*=10*/, con
 }
 
 //________________________________________________________________
-void AliToyMCEventGeneratorSimple::RunSimulationLaser(const Int_t nevents/*=1*/)
+void AliToyMCEventGeneratorSimple::RunSimulationLaser(Int_t nevents/*=1*/)
 {
   //
   // run simple simulation with equal event spacing
@@ -275,7 +275,7 @@ AliToyMCEvent* AliToyMCEventGeneratorSimple::GenerateESD(AliESDEvent &esdEvent,
   return retEvent;
 }
 //________________________________________________________________
-void AliToyMCEventGeneratorSimple::RunSimulationESD(const Int_t nevents/*=10*/, const Int_t ntracks/*=400*/)
+void AliToyMCEventGeneratorSimple::RunSimulationESD(Int_t nevents/*=10*/, Int_t ntracks/*=400*/)
 {
   //
   // run simulation using esd input with equal event spacing
@@ -335,7 +335,7 @@ void AliToyMCEventGeneratorSimple::RunSimulationESD(const Int_t nevents/*=10*/,
 }
 
 //________________________________________________________________
-void AliToyMCEventGeneratorSimple::RunSimulationBunchTrain(const Int_t nevents/*=10*/, const Int_t ntracks/*=400*/)
+void AliToyMCEventGeneratorSimple::RunSimulationBunchTrain(Int_t nevents/*=10*/, Int_t ntracks/*=400*/)
 {
   //
   // run simple simulation with equal event spacing
@@ -428,7 +428,7 @@ void AliToyMCEventGeneratorSimple::RunSimulationBunchTrain(const Int_t nevents/*
 
 
 //________________________________________________________________
-Int_t AliToyMCEventGeneratorSimple::OpenInputAndGetMaxEvents(const Int_t type, const Int_t nevents) {
+Int_t AliToyMCEventGeneratorSimple::OpenInputAndGetMaxEvents(Int_t type, Int_t nevents) {
 
   
 
@@ -465,7 +465,7 @@ Int_t AliToyMCEventGeneratorSimple::OpenInputAndGetMaxEvents(const Int_t type, c
 
 
 //________________________________________________________________
-void AliToyMCEventGeneratorSimple::RunSimulation2(const Bool_t equalspacing, const Int_t type, const Int_t nevents, const Int_t ntracks) {
+void AliToyMCEventGeneratorSimple::RunSimulation2(Bool_t equalspacing, Int_t type, Int_t nevents, Int_t ntracks) {
 
   //type==0 simple toy
   //type==1 esd input
@@ -622,7 +622,7 @@ AliToyMCEvent* AliToyMCEventGeneratorSimple::GenerateLaser(Double_t time)
 }
 
 //________________________________________________________________
-void AliToyMCEventGeneratorSimple::GetNGeneratedEventsAndSpacing(const Bool_t equalSpacing, Int_t &ngen, Double_t &spacing)
+void AliToyMCEventGeneratorSimple::GetNGeneratedEventsAndSpacing(Bool_t equalSpacing, Int_t &ngen, Double_t &spacing)
 {
 
   static Int_t bunchCounter = 0;
index 5446ebb..89f6d82 100644 (file)
@@ -23,15 +23,15 @@ class AliToyMCEventGeneratorSimple : public AliToyMCEventGenerator {
   AliToyMCEvent* GenerateLaser(Double_t time);
   
   void SetParametersToyGen(const Char_t* parfilename="$ALICE_ROOT/TPC/Upgrade/files/params.root", Double_t vertexMean = 0., Double_t vertexSigma = 7.);
-  void RunSimulation(const Int_t nevents=10, const Int_t ntracks=20, const Int_t rate=50);
-  void RunSimulationBunchTrain(const Int_t nevents=10, const Int_t ntracks=20);
-  void RunSimulationESD(const Int_t nevents=10, const Int_t ntracks=20);
-  void RunSimulationLaser(const Int_t nevents=1);
+  void RunSimulation(Int_t nevents=10, Int_t ntracks=20, Int_t rate=50);
+  void RunSimulationBunchTrain(Int_t nevents=10, Int_t ntracks=20);
+  void RunSimulationESD(Int_t nevents=10, Int_t ntracks=20);
+  void RunSimulationLaser(Int_t nevents=1);
   
   void SetInputESD(const Char_t* filename) {fInputFileNameESD = filename;}
-  Int_t OpenInputAndGetMaxEvents(const Int_t type, const Int_t nevents);
-  void RunSimulation2(const Bool_t equalspacing, const Int_t type, const Int_t nevents, const Int_t ntracks);
-  void GetNGeneratedEventsAndSpacing(const Bool_t equalSpacing, Int_t &ngen, Double_t &spacing);
+  Int_t OpenInputAndGetMaxEvents(Int_t type, Int_t nevents);
+  void RunSimulation2(Bool_t equalspacing, Int_t type, Int_t nevents, Int_t ntracks);
+  void GetNGeneratedEventsAndSpacing(Bool_t equalSpacing, Int_t &ngen, Double_t &spacing);
   Bool_t CloseInputFile();
 
  private: