Fix compiler warnings (#321)

* fix warnings

Author: iarsene

PWGDQ/Core/HistogramManager.cxx

@@ -697,7 +697,6 @@ void HistogramManager::FillHistClass(const char* className, Float_t* values)
   list varList = fVariablesMap[className];
 
   TIter next(hList);
-  auto varIter = varList.begin();
 
   TObject* h = nullptr;
   bool isProfile;

PWGDQ/Core/MCProng.cxx

@@ -49,13 +49,13 @@ MCProng::MCProng(int n) : fNGenerations(n)
 //________________________________________________________________________________________________________________
 MCProng::MCProng(int n, const std::vector<int> pdgs, const std::vector<bool> checkBothCharges, const std::vector<bool> excludePDG,
                  const std::vector<uint64_t> sourceBits, const std::vector<uint64_t> excludeSource,
-                 const std::vector<bool> useANDonSourceBitMap) : fPDGcodes(pdgs),
+                 const std::vector<bool> useANDonSourceBitMap) : fNGenerations(n),
+                                                                 fPDGcodes(pdgs),
                                                                  fCheckBothCharges(checkBothCharges),
                                                                  fExcludePDG(excludePDG),
                                                                  fSourceBits(sourceBits),
                                                                  fExcludeSource(excludeSource),
-                                                                 fUseANDonSourceBitMap(useANDonSourceBitMap),
-                                                                 fNGenerations(n){};
+                                                                 fUseANDonSourceBitMap(useANDonSourceBitMap){};
 
 //________________________________________________________________________________________________________________
 void MCProng::SetPDGcode(int generation, int code, bool checkBothCharges /*= false*/, bool exclude /*= false*/)

PWGDQ/Core/MCProng.h

@@ -89,13 +89,13 @@ class MCProng
   bool TestPDG(int i, int pdgCode) const;
   bool ComparePDG(int pdg, int prongPDG, bool checkBothCharges = false, bool exclude = false) const;
 
+  int fNGenerations;
   std::vector<int> fPDGcodes;
   std::vector<bool> fCheckBothCharges;
   std::vector<bool> fExcludePDG;
   std::vector<uint64_t> fSourceBits;
   std::vector<uint64_t> fExcludeSource;
   std::vector<bool> fUseANDonSourceBitMap;
-  int fNGenerations;
 
   ClassDef(MCProng, 1);
 };

PWGDQ/Core/MCSignal.h

@@ -101,7 +101,7 @@ class MCSignal : public TNamed
 
  private:
   std::vector<MCProng> fProngs;
-  int fNProngs;
+  unsigned int fNProngs;
   std::vector<short> fCommonAncestorIdxs;
   int fTempAncestorLabel;
 

PWGDQ/Core/MixingHandler.cxx

@@ -79,24 +79,26 @@ void MixingHandler::AddMixingVariable(int var, int nBins, std::vector<float> bin
 //_________________________________________________________________________
 int MixingHandler::GetMixingVariable(VarManager::Variables var)
 {
-  int varNum = -1;
-  for (int iVar = 0; iVar < fVariables.size(); ++iVar) {
-    if (fVariables[iVar] == var) {
-      varNum = iVar;
+  int i = 0;
+  for (auto v = fVariables.begin(); v != fVariables.end(); v++, i++) {
+    if (*v == var) {
+      return i;
     }
   }
-  return varNum;
+  return -1;
 }
 
 //_________________________________________________________________________
 std::vector<float> MixingHandler::GetMixingVariableLimits(VarManager::Variables var)
 {
   std::vector<float> binLimits;
-  for (int iVar = 0; iVar < fVariables.size(); ++iVar) {
-    if (fVariables[iVar] == var) {
-      for (int iBin = 0; iBin < fVariableLimits[iVar].GetSize(); ++iBin) {
-        binLimits.push_back(fVariableLimits[iVar].At(iBin));
+  int i = 0;
+  for (auto v = fVariables.begin(); v != fVariables.end(); v++, i++) {
+    if (*v == var) {
+      for (int iBin = 0; iBin < fVariableLimits[i].GetSize(); ++iBin) {
+        binLimits.push_back(fVariableLimits[i].At(iBin));
       }
+      break;
     }
   }
   return binLimits;
@@ -110,8 +112,8 @@ void MixingHandler::Init()
   //       The correct event category will be retrieved using the function FindEventCategory()
   //
   int size = 1;
-  for (int iVar = 0; iVar < fVariables.size(); ++iVar) {
-    size *= (fVariableLimits[iVar].GetSize() - 1);
+  for (auto v : fVariableLimits) {
+    size *= (v.GetSize() - 1);
   }
 
   fIsInitialized = kTRUE;
@@ -131,22 +133,27 @@ int MixingHandler::FindEventCategory(float* values)
   }
 
   std::vector<int> bin;
-  for (int i = 0; i < fVariables.size(); ++i) {
-    int binValue = TMath::BinarySearch(fVariableLimits[i].GetSize(), fVariableLimits[i].GetArray(), values[fVariables[i]]);
+  int iVar = 0;
+  for (auto v = fVariableLimits.begin(); v != fVariableLimits.end(); v++, iVar++) {
+    int binValue = TMath::BinarySearch((*v).GetSize(), (*v).GetArray(), values[fVariables[iVar]]);
     bin.push_back(binValue);
-    if (bin[i] == -1 || bin[i] == fVariableLimits[i].GetSize() - 1) {
+    if (bin[iVar] == -1 || bin[iVar] == (*v).GetSize() - 1) {
       return -1; // all variables must be inside limits
     }
   }
 
   int category = 0;
-  for (int iVar = 0; iVar < fVariables.size(); ++iVar) {
-    int tempCategory = 1;
-    for (int iVar2 = iVar; iVar2 < fVariables.size(); ++iVar2) {
-      if (iVar2 == iVar) {
-        tempCategory *= bin[iVar2];
+  int tempCategory = 1;
+  int iv1 = 0;
+  int iv2 = 0;
+  for (auto v1 = fVariables.begin(); v1 != fVariables.end(); v1++, iv1++) {
+    tempCategory = 1;
+    iv2 = iv1;
+    for (auto v2 = v1; v2 != fVariables.end(); v2++, iv2++) {
+      if (iv2 == iv1) {
+        tempCategory *= bin[iv2];
       } else {
-        tempCategory *= (fVariableLimits[iVar2].GetSize() - 1);
+        tempCategory *= (fVariableLimits[iv2].GetSize() - 1);
       }
     }
     category += tempCategory;
@@ -165,10 +172,10 @@ int MixingHandler::GetBinFromCategory(VarManager::Variables var, int category) c
   }
 
   // Search for the position of the variable "var" in the internal variable list of the handler
-  int tempVar;
-  for (int i = 0; i < fVariables.size(); ++i) {
-    if (fVariables[i] == var) {
-      tempVar = i;
+  int tempVar = 0;
+  for (auto v = fVariables.begin(); v != fVariables.end(); v++, tempVar++) {
+    if (*v == var) {
+      break;
     }
   }
 

PWGDQ/Core/VarManager.cxx

@@ -80,9 +80,10 @@ void VarManager::SetRunNumbers(std::vector<int> runs)
   //
   // maps the list of runs such that one can plot the list of runs nicely in a histogram axis
   //
-  for (int i = 0; i < runs.size(); ++i) {
-    fgRunMap[runs.at(i)] = i + 1;
-    fgRunStr += Form("%d;", runs.at(i));
+  int i = 0;
+  for (auto run = runs.begin(); run != runs.end(); run++, i++) {
+    fgRunMap[*run] = i + 1;
+    fgRunStr += Form("%d;", *run);
   }
 }