Fix bugs, bad practice, includes

Author: vkucera

Common/CCDB/TriggerAliases.h

@@ -12,10 +12,11 @@
 #ifndef COMMON_CCDB_TRIGGERALIASES_H_
 #define COMMON_CCDB_TRIGGERALIASES_H_
 
+#include <Rtypes.h>
+
 #include <cstdint>
 #include <map>
 #include <string>
-#include <Rtypes.h>
 
 enum triggerAliases {
   kINT7 = 0,
@@ -57,7 +58,7 @@ class TriggerAliases
   TriggerAliases() = default;
   ~TriggerAliases() = default;
 
-  void AddAlias(uint32_t aliasId, std::string classNames) { mAliasToClassNames[aliasId] = classNames; }
+  void AddAlias(uint32_t aliasId, std::string const& classNames) { mAliasToClassNames[aliasId] = classNames; }
   void AddClassIdToAlias(uint32_t aliasId, int classId);
   const std::map<uint32_t, std::string>& GetAliasToClassNamesMap() const { return mAliasToClassNames; }
   const std::map<uint32_t, ULong64_t>& GetAliasToTriggerMaskMap() const { return mAliasToTriggerMask; }

Common/CCDB/ctpRateFetcher.cxx

@@ -11,18 +11,18 @@
 
 #include "ctpRateFetcher.h"
 
-#include <map>
-#include <vector>
-
+#include "CCDB/BasicCCDBManager.h"
 #include "CommonConstants/LHCConstants.h"
 #include "DataFormatsCTP/Configuration.h"
 #include "DataFormatsCTP/Scalers.h"
 #include "DataFormatsParameters/GRPLHCIFData.h"
-#include "CCDB/BasicCCDBManager.h"
+
+#include <map>
+#include <vector>
 
 namespace o2
 {
-double ctpRateFetcher::fetch(o2::ccdb::BasicCCDBManager* ccdb, uint64_t timeStamp, int runNumber, std::string sourceName, bool fCrashOnNull)
+double ctpRateFetcher::fetch(o2::ccdb::BasicCCDBManager* ccdb, uint64_t timeStamp, int runNumber, const std::string& sourceName, bool fCrashOnNull)
 {
   setupRun(runNumber, ccdb, timeStamp);
   if (sourceName.find("ZNC") != std::string::npos) {

Common/CCDB/ctpRateFetcher.h

@@ -12,10 +12,10 @@
 #ifndef COMMON_CCDB_CTPRATEFETCHER_H_
 #define COMMON_CCDB_CTPRATEFETCHER_H_
 
-#include <string>
-
 #include "CCDB/BasicCCDBManager.h"
 
+#include <string>
+
 namespace o2
 {
 
@@ -34,7 +34,7 @@ class ctpRateFetcher
 {
  public:
   ctpRateFetcher() = default;
-  double fetch(o2::ccdb::BasicCCDBManager* ccdb, uint64_t timeStamp, int runNumber, std::string sourceName, bool fCrashOnNull = true);
+  double fetch(o2::ccdb::BasicCCDBManager* ccdb, uint64_t timeStamp, int runNumber, const std::string& sourceName, bool fCrashOnNull = true);
 
   void setManualCleanup(bool manualCleanup = true) { mManualCleanup = manualCleanup; }
 

Common/Core/CollisionAssociation.h

@@ -20,13 +20,13 @@
 #ifndef COMMON_CORE_COLLISIONASSOCIATION_H_
 #define COMMON_CORE_COLLISIONASSOCIATION_H_
 
-#include <vector>
-#include <memory>
-#include <utility>
-
 #include "CommonConstants/LHCConstants.h"
-#include "Framework/AnalysisDataModel.h"
 #include "Framework/ASoAHelpers.h"
+#include "Framework/AnalysisDataModel.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
 
 namespace o2::aod
 {
@@ -191,58 +191,58 @@ class CollisionAssociation
       for (auto& iterationWindow : trackIterationWindows) {
         bool iteratorMoved = false;
         const bool isAssignedTrackWindow = (iterationWindow.first != iterationWindow.second) ? iterationWindow.first.has_collision() : false;
-        for (auto track = iterationWindow.first; track != iterationWindow.second; ++track) {
-          int64_t trackBC = globalBC[track.filteredIndex()];
+        for (auto trackInWindow = iterationWindow.first; trackInWindow != iterationWindow.second; ++trackInWindow) {
+          int64_t trackBC = globalBC[trackInWindow.filteredIndex()];
           if (trackBC < 0) {
             continue;
           }
 
           // Optimization to avoid looping over the full track list each time. This builds on that tracks are sorted by BCs (which they should be because collisions are sorted by BCs)
-          const int64_t bcOffset = trackBC - (int64_t)collBC;
+          const int64_t bcOffset = trackBC - static_cast<int64_t>(collBC);
           if constexpr (isCentralBarrel) {
             // only for blocks with collision association
             if (isAssignedTrackWindow) {
               constexpr int margin = 200;
               if (!iteratorMoved && bcOffset > -bcOffsetMax - margin) {
-                iterationWindow.first.setCursor(track.filteredIndex());
+                iterationWindow.first.setCursor(trackInWindow.filteredIndex());
                 iteratorMoved = true;
-                LOGP(debug, "Moving iterator begin {}", track.filteredIndex());
+                LOGP(debug, "Moving iterator begin {}", trackInWindow.filteredIndex());
               } else if (bcOffset > bcOffsetMax + margin) {
-                LOGP(debug, "Stopping iterator {}", track.filteredIndex());
+                LOGP(debug, "Stopping iterator {}", trackInWindow.filteredIndex());
                 break;
               }
             }
           }
 
-          int64_t bcOffsetWindow = trackBCCache[track.filteredIndex()] - (int64_t)collBC;
+          int64_t bcOffsetWindow = trackBCCache[trackInWindow.filteredIndex()] - static_cast<int64_t>(collBC);
           if (std::abs(bcOffsetWindow) > bcOffsetMax) {
             continue;
           }
 
           float trackTime = 0;
           float trackTimeRes = 0;
           if constexpr (isCentralBarrel) {
-            if (mUsePvAssociation && track.isPVContributor()) {
-              trackTime = track.collision().collisionTime();        // if PV contributor, we assume the time to be the one of the collision
-              trackTimeRes = o2::constants::lhc::LHCBunchSpacingNS; // 1 BC
+            if (mUsePvAssociation && trackInWindow.isPVContributor()) {
+              trackTime = trackInWindow.collision().collisionTime(); // if PV contributor, we assume the time to be the one of the collision
+              trackTimeRes = o2::constants::lhc::LHCBunchSpacingNS;  // 1 BC
             } else {
-              trackTime = track.trackTime();
-              trackTimeRes = track.trackTimeRes();
+              trackTime = trackInWindow.trackTime();
+              trackTimeRes = trackInWindow.trackTimeRes();
             }
           } else {
-            trackTime = track.trackTime();
-            trackTimeRes = track.trackTimeRes();
+            trackTime = trackInWindow.trackTime();
+            trackTimeRes = trackInWindow.trackTimeRes();
           }
 
           const float deltaTime = trackTime - collTime + bcOffset * o2::constants::lhc::LHCBunchSpacingNS;
           float sigmaTimeRes2 = collTimeRes2 + trackTimeRes * trackTimeRes;
-          LOGP(debug, "collision time={}, collision time res={}, track time={}, track time res={}, bc collision={}, bc track={}, delta time={}", collTime, collision.collisionTimeRes(), track.trackTime(), track.trackTimeRes(), collBC, trackBC, deltaTime);
+          LOGP(debug, "collision time={}, collision time res={}, track time={}, track time res={}, bc collision={}, bc track={}, delta time={}", collTime, collision.collisionTimeRes(), trackInWindow.trackTime(), trackInWindow.trackTimeRes(), collBC, trackBC, deltaTime);
 
           float thresholdTime = 0.;
           if constexpr (isCentralBarrel) {
-            if (mUsePvAssociation && track.isPVContributor()) {
+            if (mUsePvAssociation && trackInWindow.isPVContributor()) {
               thresholdTime = trackTimeRes;
-            } else if (TESTBIT(track.flags(), o2::aod::track::TrackTimeResIsRange)) {
+            } else if (TESTBIT(trackInWindow.flags(), o2::aod::track::TrackTimeResIsRange)) {
               // the track time resolution is a range, not a gaussian resolution
               thresholdTime = trackTimeRes + mNumSigmaForTimeCompat * std::sqrt(collTimeRes2) + mTimeMargin;
             } else {
@@ -262,7 +262,7 @@ class CollisionAssociation
 
           if (std::abs(deltaTime) < thresholdTime) {
             const auto collIdx = collision.globalIndex();
-            const auto trackIdx = track.globalIndex();
+            const auto trackIdx = trackInWindow.globalIndex();
             LOGP(debug, "Filling track id {} for coll id {}", trackIdx, collIdx);
             association(collIdx, trackIdx);
             if (mFillTableOfCollIdsPerTrack) {
@@ -278,9 +278,9 @@ class CollisionAssociation
     // create reverse index track to collisions if enabled
     if (mFillTableOfCollIdsPerTrack) {
       std::vector<int> empty{};
-      for (const auto& track : tracksUnfiltered) {
+      for (const auto& trackUnfiltered : tracksUnfiltered) {
 
-        const auto trackId = track.globalIndex();
+        const auto trackId = trackUnfiltered.globalIndex();
         if (collsPerTrack[trackId] == nullptr) {
           reverseIndices(empty);
         } else {

Common/Core/EventPlaneHelper.cxx

@@ -20,13 +20,13 @@
 
 #include "Common/Core/EventPlaneHelper.h"
 
+#include "TMath.h"
+#include "TVector3.h"
+
 #include <algorithm>
 #include <iterator>
-#include <vector>
 #include <memory>
-
-#include "TMath.h"
-#include "TVector3.h"
+#include <vector>
 
 double EventPlaneHelper::GetPhiFV0(int chno, o2::fv0::Geometry* fv0geom)
 {
@@ -37,8 +37,8 @@ double EventPlaneHelper::GetPhiFV0(int chno, o2::fv0::Geometry* fv0geom)
   float offsetX = 0.;
   float offsetY = 0.;
 
-  int cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27,
-                       32, 40, 33, 41, 34, 42, 35, 43};
+  const int cellsInLeft[] = {0, 1, 2, 3, 8, 9, 10, 11, 16, 17, 18, 19, 24, 25, 26, 27,
+                             32, 40, 33, 41, 34, 42, 35, 43};
   bool isChnoInLeft = std::find(std::begin(cellsInLeft), std::end(cellsInLeft), chno) != std::end(cellsInLeft);
 
   if (isChnoInLeft) {

Common/Core/FFitWeights.cxx

@@ -16,12 +16,12 @@
 
 #include "FFitWeights.h"
 
-#include <string>
+#include <TSpline.h>
+
 #include <cstdio>
+#include <string>
 #include <vector>
 
-#include <TSpline.h>
-
 ClassImp(FFitWeights)
 
   FFitWeights::FFitWeights() : TNamed("", ""),
@@ -111,7 +111,7 @@ void FFitWeights::addArray(TObjArray* targ, TObjArray* sour)
   }
 };
 
-void FFitWeights::qSelection(std::vector<int> nhv, std::vector<std::string> stv) /* only execute OFFLINE */
+void FFitWeights::qSelection(std::vector<int> const& nhv, std::vector<std::string> const& stv) /* only execute OFFLINE */
 {
   TObjArray* tar{nullptr};
 

Common/Core/FFitWeights.h

@@ -17,22 +17,22 @@
 #ifndef COMMON_CORE_FFITWEIGHTS_H_
 #define COMMON_CORE_FFITWEIGHTS_H_
 
-#include <vector>
-#include <string>
-#include <utility>
-#include <algorithm>
-#include <complex>
-#include <memory>
-
+#include "TCollection.h"
+#include "TFile.h"
+#include "TH1D.h"
+#include "TH2D.h"
+#include "TH3D.h"
+#include "TMath.h"
 #include "TNamed.h"
 #include "TObjArray.h"
-#include "TH3D.h"
-#include "TH2D.h"
-#include "TH1D.h"
-#include "TFile.h"
-#include "TCollection.h"
 #include "TString.h"
-#include "TMath.h"
+
+#include <algorithm>
+#include <complex>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 class FFitWeights : public TNamed
 {
@@ -53,11 +53,11 @@ class FFitWeights : public TNamed
   TAxis* getqVecAx() { return qAxis; }
 
   Long64_t Merge(TCollection* collist);
-  void qSelection(std::vector<int> nhv, std::vector<std::string> stv);
+  void qSelection(std::vector<int> const& nhv, std::vector<std::string> const& stv);
   float eval(float centr, const float& dqn, const int nh, const char* pf = "");
   void setResolution(int res) { nResolution = res; }
   int getResolution() const { return nResolution; }
-  void setQnType(std::vector<std::pair<int, std::string>> qninp) { qnTYPE = qninp; }
+  void setQnType(std::vector<std::pair<int, std::string>> const& qninp) { qnTYPE = qninp; }
 
  private:
   TObjArray* fW_data;

Common/Core/MetadataHelper.cxx

@@ -78,12 +78,7 @@ bool MetadataHelper::isFullyDefined() const
   if (!mIsInitialized) {
     LOG(fatal) << "Metadata not initialized";
   }
-  for (const auto& key : mMetadata) {
-    if (!isKeyDefined(key.first)) {
-      return false;
-    }
-  }
-  return true;
+  return std::all_of(mMetadata.begin(), mMetadata.end(), [this](const auto& key) { return isKeyDefined(key.first); });
 }
 
 std::string MetadataHelper::get(std::string const& key) const

Common/Core/OrbitRange.h

@@ -13,16 +13,17 @@
 // Container to store minimum and maximum orbit counter
 //
 
-#ifndef OrbitRange_H
-#define OrbitRange_H
+#ifndef COMMON_CORE_ORBITRANGE_H_
+#define COMMON_CORE_ORBITRANGE_H_
+
+#include <TNamed.h>
 
-#include "TNamed.h"
 class TCollection;
 
 class OrbitRange : public TNamed
 {
  public:
-  OrbitRange(const char* name = "orbitRange") : TNamed(name, name), fRunNumber(0), fMinOrbit(0xFFFFFFFF), fMaxOrbit(0) {}
+  explicit OrbitRange(const char* name = "orbitRange") : TNamed(name, name), fRunNumber(0), fMinOrbit(0xFFFFFFFF), fMaxOrbit(0) {}
   ~OrbitRange() {}
   void SetRunNumber(uint32_t runNumber) { fRunNumber = runNumber; }
   void SetMinOrbit(uint32_t orbit) { fMinOrbit = orbit; }
@@ -39,4 +40,4 @@ class OrbitRange : public TNamed
   ClassDef(OrbitRange, 1)
 };
 
-#endif
+#endif // COMMON_CORE_ORBITRANGE_H_