[PWGJE] Use const& and std::move to avoid copies (#17710)

Author: vkucera

PWGJE/Core/JetBkgSubUtils.cxx

@@ -29,6 +29,7 @@
 #include <algorithm>
 #include <cstdlib>
 #include <tuple>
+#include <utility>
 #include <vector>
 
 #include <math.h>
@@ -41,7 +42,7 @@ JetBkgSubUtils::JetBkgSubUtils(float jetBkgR_out, float bkgEtaMin_out, float bkg
                                                                                                                                                                                                                                                           constSubAlpha(constSubAlpha_out),
                                                                                                                                                                                                                                                           constSubRMax(constSubRMax_out),
                                                                                                                                                                                                                                                           nHardReject(nHardReject_out),
-                                                                                                                                                                                                                                                          ghostAreaSpec(ghostAreaSpec_out)
+                                                                                                                                                                                                                                                          ghostAreaSpec(std::move(ghostAreaSpec_out))
 
 {
 }
@@ -162,11 +163,11 @@ std::vector<fastjet::PseudoJet> JetBkgSubUtils::doJetConstSub(std::vector<fastje
   return constituentSub(jets);
 }
 
-double JetBkgSubUtils::getMd(fastjet::PseudoJet jet) const
+double JetBkgSubUtils::getMd(const fastjet::PseudoJet& jet) const
 {
   // Refere to https://arxiv.org/abs/1211.2811 for the rhoM caclulation
   double sum(0);
-  for (auto constituent : jet.constituents()) {
+  for (const auto& constituent : jet.constituents()) {
     sum += TMath::Sqrt(constituent.m() * constituent.m() + constituent.pt() * constituent.pt()) - constituent.pt();
   }
 

PWGJE/Core/JetBkgSubUtils.h

@@ -24,6 +24,7 @@
 #include <fastjet/Selector.hh>
 
 #include <tuple>
+#include <utility>
 #include <vector>
 
 #include <math.h>
@@ -107,7 +108,7 @@ class JetBkgSubUtils
     constSubRMax = rmax_out;
   }
   void setDoRhoMassSub(bool doMSub_out = true) { doRhoMassSub = doMSub_out; }
-  void setGhostAreaSpec(fastjet::GhostedAreaSpec ghostAreaSpec_out) { ghostAreaSpec = ghostAreaSpec_out; }
+  void setGhostAreaSpec(fastjet::GhostedAreaSpec ghostAreaSpec_out) { ghostAreaSpec = std::move(ghostAreaSpec_out); }
 
   // Getters
   float getJetBkgR() const { return jetBkgR; }
@@ -124,7 +125,7 @@ class JetBkgSubUtils
   fastjet::Selector getRhoSelector() const { return selRho; }
 
   // Calculate the jet mass
-  double getMd(fastjet::PseudoJet jet) const;
+  double getMd(const fastjet::PseudoJet& jet) const;
 
  protected:
   float jetBkgR = 0.2;

PWGJE/Core/JetDerivedDataUtilities.h

@@ -63,7 +63,7 @@ enum JCollisionSubGeneratorId {
 };
 
 template <typename T>
-bool selectCollision(T const& collision, const std::vector<int>& eventSelectionMaskBits, bool skipMBGapEvents = true, bool rctSelection = true, std::string rctLabel = "CBT_hadronPID", bool rejectLimitedAcceptanceRct = false, bool requireZDCRct = false)
+bool selectCollision(T const& collision, const std::vector<int>& eventSelectionMaskBits, bool skipMBGapEvents = true, bool rctSelection = true, const std::string& rctLabel = "CBT_hadronPID", bool rejectLimitedAcceptanceRct = false, bool requireZDCRct = false)
 {
 
   if (skipMBGapEvents && collision.getSubGeneratorId() == JCollisionSubGeneratorId::mbGap) {
@@ -96,7 +96,7 @@ bool selectCollision(T const& collision, const std::vector<int>& eventSelectionM
   return !isOrCondition;
 }
 
-bool eventSelectionMasksContainSelection(const std::string& eventSelectionMasks, std::string selection)
+bool eventSelectionMasksContainSelection(const std::string& eventSelectionMasks, const std::string& selection)
 {
   size_t position = 0;
   while ((position = eventSelectionMasks.find(selection, position)) != std::string::npos) {
@@ -325,7 +325,7 @@ bool selectTrigger(T const& collision, int triggerMaskBit)
   return collision.triggerSel() & (1ULL << triggerMaskBit);
 }
 
-bool triggerMasksContainTrigger(const std::string& triggerMasks, std::string trigger)
+bool triggerMasksContainTrigger(const std::string& triggerMasks, const std::string& trigger)
 {
   size_t position = 0;
   while ((position = triggerMasks.find(trigger, position)) != std::string::npos) {
@@ -733,7 +733,7 @@ bool selectTrackDcaZ(T const& track, double dcaZmax = 99.)
   return std::abs(track.dcaZ()) < dcaZmax;
 }
 
-std::vector<int> initialiseClusterDefinitions(const std::string clusterDefinitions)
+std::vector<int> initialiseClusterDefinitions(const std::string& clusterDefinitions)
 {
   std::vector<int> clusterDefinitionsVec;
   if (clusterDefinitions.empty()) {

PWGJE/Core/JetFindingUtilities.h

@@ -38,6 +38,7 @@
 #include <memory>
 #include <string>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 #include <math.h>
@@ -278,9 +279,9 @@ bool analyseV0s(std::vector<fastjet::PseudoJet>& inputParticles, T const& v0s, f
  * @param doHFJetFinding set whether only jets containing a HF candidate are saved
  */
 template <typename T, typename U, typename V>
-void findJets(JetFinder& jetFinder, std::vector<fastjet::PseudoJet>& inputParticles, float jetPtMin, float jetPtMax, std::vector<double> jetRadius, float jetAreaFractionMin, T const& collision, U& jetsTable, V& constituentsTable, std::shared_ptr<THn> thnSparseJet, bool fillThnSparse, bool doCandidateJetFinding = false)
+void findJets(JetFinder& jetFinder, std::vector<fastjet::PseudoJet>& inputParticles, float jetPtMin, float jetPtMax, std::vector<double> jetRadius, float jetAreaFractionMin, T const& collision, U& jetsTable, V& constituentsTable, const std::shared_ptr<THn>& thnSparseJet, bool fillThnSparse, bool doCandidateJetFinding = false)
 {
-  auto jetRValues = static_cast<std::vector<double>>(jetRadius);
+  auto jetRValues = static_cast<std::vector<double>>(std::move(jetRadius));
   jetFinder.jetPtMin = jetPtMin;
   jetFinder.jetPtMax = jetPtMax;
   for (auto R : jetRValues) {

PWGJE/Core/MlResponseHfTagging.h

@@ -34,10 +34,9 @@
 // Fill the map of available input features
 // the key is the feature's name (std::string)
 // the value is the corresponding value in EnumInputFeatures
-#define FILL_MAP_BJET(FEATURE)                                 \
-  {                                                            \
-    #FEATURE, static_cast<uint8_t>(InputFeaturesBTag::FEATURE) \
-  }
+#define FILL_MAP_BJET(FEATURE) \
+  {                            \
+    #FEATURE, static_cast<uint8_t>(InputFeaturesBTag::FEATURE)}
 
 // Check if the index of mCachedIndices (index associated to a FEATURE)
 // matches the entry in EnumInputFeatures associated to this FEATURE
@@ -424,7 +423,7 @@ class GNNBjetAllocator : public TensorAllocator
 
  public:
   GNNBjetAllocator() : TensorAllocator(), nJetFeat(4), nTrkFeat(13), nFlav(3), nTrkOrigin(5), maxNNodes(40), tfFunc([](float x) { return x; }) {}
-  GNNBjetAllocator(int64_t nJetFeat, int64_t nTrkFeat, int64_t nFlav, int64_t nTrkOrigin, std::vector<float>& tfJetMean, std::vector<float>& tfJetStdev, std::vector<float>& tfTrkMean, std::vector<float>& tfTrkStdev, int64_t maxNNodes = 40, std::string tfFuncType = "linear")
+  GNNBjetAllocator(int64_t nJetFeat, int64_t nTrkFeat, int64_t nFlav, int64_t nTrkOrigin, std::vector<float>& tfJetMean, std::vector<float>& tfJetStdev, std::vector<float>& tfTrkMean, std::vector<float>& tfTrkStdev, int64_t maxNNodes = 40, const std::string& tfFuncType = "linear")
     : TensorAllocator(), nJetFeat(nJetFeat), nTrkFeat(nTrkFeat), nFlav(nFlav), nTrkOrigin(nTrkOrigin), maxNNodes(maxNNodes), tfJetMean(tfJetMean), tfJetStdev(tfJetStdev), tfTrkMean(tfTrkMean), tfTrkStdev(tfTrkStdev), tfFunc([](float x) { return x; })
   {
     if (tfFuncType == "asinh") {

PWGJE/DataModel/EMCALClusterDefinition.h

@@ -17,6 +17,7 @@
 #define PWGJE_DATAMODEL_EMCALCLUSTERDEFINITION_H_
 
 #include <string>
+#include <utility>
 
 namespace o2::aod
 {
@@ -50,7 +51,7 @@ struct EMCALClusterDefinition {
     algorithm = pAlgorithm;
     storageID = pStorageID;
     selectedCellType = pSelectedCellType;
-    name = pName;
+    name = std::move(pName);
     seedEnergy = pSeedEnergy;
     minCellEnergy = pMinCellEnergy;
     timeMin = pTimeMin;

PWGJE/TableProducer/derivedDataProducer.cxx

@@ -620,7 +620,7 @@ struct JetDerivedDataProducerTask {
   void processClusters(aod::Collision const&, aod::EMCALClusters const& clusters, aod::EMCALClusterCells const& cells, aod::Calos const&, aod::EMCALMatchedTracks const& matchedTracks, soa::Join<aod::Tracks, aod::TracksExtra> const&)
   {
 
-    for (auto cluster : clusters) {
+    for (const auto& cluster : clusters) {
 
       auto const clusterCells = cells.sliceBy(preslices.perClusterCells, cluster.globalIndex());
 

PWGJE/TableProducer/derivedDataSelector.cxx

@@ -155,9 +155,9 @@ struct JetDerivedDataSelector {
 
   void processSelectMcCollisionsPerCollision(aod::JMcCollisions const& mcCollisions, soa::Join<aod::JCollisions, aod::JMcCollisionLbs> const& collisions)
   {
-    for (auto mcCollision : mcCollisions) {
+    for (const auto& mcCollision : mcCollisions) {
       const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex());
-      for (auto collision : collisionsPerMcCollision) {
+      for (const auto& collision : collisionsPerMcCollision) {
         if (collisionFlag[collision.globalIndex()]) {
           mcCollisionFlag[mcCollision.globalIndex()] = true;
         }

PWGJE/TableProducer/derivedDataWriter.cxx

@@ -713,11 +713,11 @@ struct JetDerivedDataWriter {
 
         const auto particlesPerMcCollision = particles.sliceBy(preslices.ParticlesPerMcCollision, mcCollision.globalIndex());
 
-        for (auto particle : particlesPerMcCollision) {
+        for (const auto& particle : particlesPerMcCollision) {
           particleMapping[particle.globalIndex()] = particleTableIndex;
           particleTableIndex++;
         }
-        for (auto particle : particlesPerMcCollision) {
+        for (const auto& particle : particlesPerMcCollision) {
 
           std::vector<int32_t> mothersIds;
           int daughtersIds[2] = {-1, -1};

PWGJE/TableProducer/mcOutlierRejector.cxx

@@ -69,7 +69,7 @@ struct McOutlierRejectorTask {
     if (selectionObjects.size() != 0) {
       float selectionObjectPt = 0.0;
       if constexpr (std::is_same_v<std::decay_t<T>, aod::JetTracksMCD> || std::is_same_v<std::decay_t<T>, aod::JetParticles>) {
-        for (auto selectionObject : selectionObjects) {
+        for (const auto& selectionObject : selectionObjects) {
           selectionObjectPt = selectionObject.pt();
           // may be slow - could save only MC particle then check difference only for tracks IDd as outliers?
           if constexpr (std::is_same_v<std::decay_t<T>, aod::JetTracksMCD>) { // tracks