[PWGUD] Use const& and std::move to avoid copies

PWGUD/AQC/udQC.cxx

@@ -1,4 +1,4 @@
 // Copyright 2019-2020 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -38,7 +38,7 @@
 
 #include <TH1.h>
 #include <TH2.h>
 #include <TLorentzVector.h>
 
 #include <algorithm>
 #include <cstddef>
@@ -167,7 +167,7 @@
       registry.add("CleanFIT1/cF1FDDAamp", "#cF1FDDAamp", {HistType::kTH2F, {{20, -0.5, 19.5}, {1000, -0.5, 999.5}}});
       registry.add("CleanFIT1/cF1FDDCamp", "#cF1FDDCamp", {HistType::kTH2F, {{20, -0.5, 19.5}, {1000, -0.5, 999.5}}});
 
       for (auto n{0}; n < 5; n++) {
         registry.add(hcFIT1s[n].data(), hcFIT1s[n].data(), {HistType::kTH2F, {{20, -0.5, 19.5}, {2, -0.5, 1.5}}});
       }
     }
@@ -179,7 +179,7 @@
       registry.add("CleanFIT2/cF2FDDAamp", "#cF2FDDAamp", {HistType::kTH2F, {{20, -0.5, 19.5}, {1000, -0.5, 999.5}}});
       registry.add("CleanFIT2/cF2FDDCamp", "#cF2FDDCamp", {HistType::kTH2F, {{20, -0.5, 19.5}, {1000, -0.5, 999.5}}});
 
       for (auto n{0}; n < 5; n++) {
         registry.add(hcFIT2s[n].data(), hcFIT2s[n].data(), {HistType::kTH2F, {{20, -0.5, 19.5}, {2, -0.5, 1.5}}});
         registry.add(hcRelBCs[n].data(), hcRelBCs[n].data(), {HistType::kTH1F, {{3564, -0.5, 3563.5}}});
       }
@@ -213,7 +213,7 @@
                    TCs const& tracks, FWs const& fwdtracks, ATs const& /*ambtracks*/, AFTs const& /*ambfwdtracks*/,
                    aod::FT0s const& /*ft0s*/, aod::FV0As const& /*fv0as*/, aod::FDDs const& /*fdds*/,
                    aod::Zdcs& zdcs, aod::Calos& calos,
                    aod::V0s const& v0s, aod::Cascades const& cascades)
   {
     // LOGF(debug, "<UDQC. Collision %d", collision.globalIndex());
     // LOGF(debug, "<UDQC> Start %i", abcrs.size());
@@ -423,13 +423,13 @@
     bool goodpts = true;
     bool goodnchs = true;
     auto netCharge = 0;
     auto lvtmp = TLorentzVector();
     auto ivm = TLorentzVector();
     if (isDGcandidate) {
 
       // which particle hypothesis? // Pion hypothesis has been used currently
       auto mass2Use = constants::physics::MassPionCharged;
       if (diffCuts.pidHypothesis() == 321) {
         mass2Use = constants::physics::MassKaonCharged;
       }
 
@@ -502,7 +502,7 @@
       registry.get<TH1>(HIST("DG/netCharge"))->Fill(netCharge);
 
       // Invariant mass with 2 PV contributors and all contributors
       if (collision.numContrib() == 2) {
         bool ispipiCand = true;
         for (auto const& track : tracks) {
           if (track.isPVContributor()) {
@@ -711,7 +711,7 @@
       return;
     }
 
-    for (auto fv0 : fv0s) {
+    for (const auto& fv0 : fv0s) {
       registry.get<TH1>(HIST("FV0/hV0A"))->Fill(fv0.time());
       // side A
       for (size_t ind = 0; ind < fv0.channel().size(); ind++) {
@@ -738,7 +738,7 @@
         registry.get<TH1>(HIST("FT0/hT0AC"))->Fill(collision.t0AC());
       }
     }
-    for (auto ft0 : ft0s) {
+    for (const auto& ft0 : ft0s) {
       registry.get<TH1>(HIST("FT0/hT0A"))->Fill(ft0.timeA());
       registry.get<TH1>(HIST("FT0/hT0C"))->Fill(ft0.timeC());
 
@@ -760,7 +760,7 @@
   {
     // LOGF(debug, "<FDDSignals> %d", fdds.size());
 
-    for (auto fdd : fdds) {
+    for (const auto& fdd : fdds) {
 
       registry.get<TH1>(HIST("FDD/hFDDA"))->Fill(fdd.timeA());
       registry.get<TH1>(HIST("FDD/hFDDC"))->Fill(fdd.timeC());

PWGUD/Core/DGCutparHolder.cxx

@@ -11,6 +11,7 @@
 
 #include "PWGUD/Core/DGCutparHolder.h"
 
+#include <utility>
 #include <vector>
 
 // setter
@@ -45,7 +46,7 @@ void DGCutparHolder::SetNTracks(int MinNTracks, int MaxNTracks)
 }
 void DGCutparHolder::SetNetCharges(std::vector<int> netCharges)
 {
-  mNetCharges = netCharges;
+  mNetCharges = std::move(netCharges);
 }
 void DGCutparHolder::SetPidHypothesis(int pidHypo)
 {
@@ -102,11 +103,11 @@ void DGCutparHolder::SetMaxFITtime(float maxFITtime)
 }
 void DGCutparHolder::SetFITAmpLimits(std::vector<float> FITAmpLimits)
 {
-  mFITAmpLimits = FITAmpLimits;
+  mFITAmpLimits = std::move(FITAmpLimits);
 }
 void DGCutparHolder::SetCollisionSel(std::vector<int> collisionSel)
 {
-  mCollisionSel = collisionSel;
+  mCollisionSel = std::move(collisionSel);
 }
 
 // getter

PWGUD/Core/DGCutparHolder.h

@@ -14,6 +14,7 @@
 
 #include <Rtypes.h>
 
+#include <utility>
 #include <vector>
 
 // object to hold customizable cut values
@@ -40,7 +41,7 @@ class DGCutparHolder
                  bool TOR = true,
                  float maxFITtime = 4,
                  std::vector<float> FITAmpLimits = {0., 0., 0., 0., 0.},
-                 std::vector<int> collisionSel = {1, 1, 1, 0, 1, 0, 0}) : mNDtcoll{ndtcoll}, mMinNBCs{nMinBCs}, mWithFwdTracks{withFwdTracks}, mGlobalTracksOnly{globalTracksOnly}, mITSOnlyTracks{ITSonlyTracks}, mMinRgtrwTOF{minrgtrwTOF}, mMinNTracks{MinNTracks}, mMaxNTracks{MaxNTracks}, mNetCharges{NetCharges}, mPidHypo{pidHypo}, mMinVertexPosz{MinPosz}, mMaxVertexPosz{MaxPosz}, mMinPt{minPt}, mMaxPt{maxPt}, mMinEta{minEta}, mMaxEta{maxEta}, mMinIVM{minIVM}, mMaxIVM{maxIVM}, mMaxNSigmaTPC{maxNSigmaTPC}, mMaxNSigmaTOF{maxNSigmaTOF}, mTVX{TVX}, mTSC{TSC}, mTCE{TCE}, mTOR{TOR}, mMaxFITtime{maxFITtime}, mFITAmpLimits{FITAmpLimits}, mCollisionSel{collisionSel}
+                 std::vector<int> collisionSel = {1, 1, 1, 0, 1, 0, 0}) : mNDtcoll{ndtcoll}, mMinNBCs{nMinBCs}, mWithFwdTracks{withFwdTracks}, mGlobalTracksOnly{globalTracksOnly}, mITSOnlyTracks{ITSonlyTracks}, mMinRgtrwTOF{minrgtrwTOF}, mMinNTracks{MinNTracks}, mMaxNTracks{MaxNTracks}, mNetCharges{std::move(NetCharges)}, mPidHypo{pidHypo}, mMinVertexPosz{MinPosz}, mMaxVertexPosz{MaxPosz}, mMinPt{minPt}, mMaxPt{maxPt}, mMinEta{minEta}, mMaxEta{maxEta}, mMinIVM{minIVM}, mMaxIVM{maxIVM}, mMaxNSigmaTPC{maxNSigmaTPC}, mMaxNSigmaTOF{maxNSigmaTOF}, mTVX{TVX}, mTSC{TSC}, mTCE{TCE}, mTOR{TOR}, mMaxFITtime{maxFITtime}, mFITAmpLimits{std::move(FITAmpLimits)}, mCollisionSel{std::move(collisionSel)}
   {
   }
 

PWGUD/Core/DGPIDSelector.cxx

@@ -22,6 +22,7 @@
 #include <cstdlib>
 #include <functional>
 #include <string>
+#include <utility>
 #include <vector>
 
 // -----------------------------------------------------------------------------
@@ -87,7 +88,7 @@ DGPIDCuts::DGPIDCuts()
 
 DGPIDCuts::DGPIDCuts(std::vector<float> PIDCutValues)
 {
-  setPIDCuts(PIDCutValues);
+  setPIDCuts(std::move(PIDCutValues));
 }
 
 DGPIDCuts::~DGPIDCuts()
@@ -196,7 +197,7 @@ void DGAnaparHolder::SetdBC(int min, int max)
   mdBCMax = max;
 }
 
-void DGAnaparHolder::SetFITvetoes(std::vector<int> vetoes)
+void DGAnaparHolder::SetFITvetoes(const std::vector<int>& vetoes)
 {
 
   if (vetoes.size() == 5) {
@@ -254,22 +255,22 @@ void DGAnaparHolder::SetnCombine(std::size_t nComb)
 
 void DGAnaparHolder::SetnetCharges(std::vector<int> charges)
 {
-  mNetCharges = charges;
+  mNetCharges = std::move(charges);
 }
 
 void DGAnaparHolder::SetunlikeCharges(std::vector<int> charges)
 {
-  mUnlikeCharges = charges;
+  mUnlikeCharges = std::move(charges);
 }
 
 void DGAnaparHolder::SetlikeCharges(std::vector<int> charges)
 {
-  mLikeCharges = charges;
+  mLikeCharges = std::move(charges);
 }
 
 void DGAnaparHolder::SetPIDs(std::vector<int> pids)
 {
-  mDGPIDs = pids;
+  mDGPIDs = std::move(pids);
 }
 
 // -----------------------------------------------------------------------------
@@ -435,7 +436,7 @@ void DGPIDSelector::Print()
   mAnaPars.Print();
 }
 
-void DGPIDSelector::init(DGAnaparHolder anaPars)
+void DGPIDSelector::init(const DGAnaparHolder& anaPars)
 {
   mAnaPars = anaPars;
   mUnlikeIVMs.clear();

PWGUD/Core/DGPIDSelector.h

@@ -21,6 +21,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdlib>
+#include <utility>
 #include <vector>
 
 const int numDGPIDCutParameters = 9;
@@ -124,7 +125,7 @@ struct DGAnaparHolder {
                  std::vector<int> unlikeCharges = {0},
                  std::vector<int> likeCharges = {-2, 2},
                  std::vector<int> DGPIDs = {211, 211},
-                 std::vector<float> DGPIDCutValues = {}) : mMinNTracks{MinNTracks}, mMaxNTracks{MaxNTracks}, mMinRgtrwTOF{minrgtrwTOF}, mMaxDCAxy{maxDCAxy}, mMaxDCAz{maxDCAz}, mdBCMin{dBCMin}, mdBCMax{dBCMax}, mFITvetoes{FITvetoes}, mITSOnlyTracks{ITSonlyTracks}, mMinNClTPC{minNClTPC}, mMaxNClTPC{maxNClTPC}, mMinChi2NClTPC{minChi2NClTPC}, mMaxChi2NClTPC{maxChi2NClTPC}, mMinpt{minpt}, mMaxpt{maxpt}, mMineta{mineta}, mMaxeta{maxeta}, mMinAlpha{minalpha}, mMaxAlpha{maxalpha}, mMinptsys{minptsys}, mMaxptsys{maxptsys}, mNCombine{nCombine}, mNetCharges{netCharges}, mUnlikeCharges{unlikeCharges}, mLikeCharges{likeCharges}, mDGPIDs{DGPIDs}, mDGPIDCutValues{DGPIDCutValues}
+                 std::vector<float> DGPIDCutValues = {}) : mMinNTracks{MinNTracks}, mMaxNTracks{MaxNTracks}, mMinRgtrwTOF{minrgtrwTOF}, mMaxDCAxy{maxDCAxy}, mMaxDCAz{maxDCAz}, mdBCMin{dBCMin}, mdBCMax{dBCMax}, mFITvetoes{std::move(FITvetoes)}, mITSOnlyTracks{ITSonlyTracks}, mMinNClTPC{minNClTPC}, mMaxNClTPC{maxNClTPC}, mMinChi2NClTPC{minChi2NClTPC}, mMaxChi2NClTPC{maxChi2NClTPC}, mMinpt{minpt}, mMaxpt{maxpt}, mMineta{mineta}, mMaxeta{maxeta}, mMinAlpha{minalpha}, mMaxAlpha{maxalpha}, mMinptsys{minptsys}, mMaxptsys{maxptsys}, mNCombine{nCombine}, mNetCharges{std::move(netCharges)}, mUnlikeCharges{std::move(unlikeCharges)}, mLikeCharges{std::move(likeCharges)}, mDGPIDs{std::move(DGPIDs)}, mDGPIDCutValues{std::move(DGPIDCutValues)}
   {
     if (mdBCMin < -16) {
       mdBCMin = -16;
@@ -148,7 +149,7 @@ struct DGAnaparHolder {
   void SetMinRgtrwTOF(float);
   void SetmaxDCA(float, float);
   void SetdBC(int, int);
-  void SetFITvetoes(std::vector<int>);
+  void SetFITvetoes(const std::vector<int>&);
   void SetITSOnlyTracks(bool);
   void SetNClTPC(int, int);
   void SetChi2NClTPC(float, float);
@@ -239,7 +240,7 @@ struct DGParticle {
  public:
   DGParticle();
   template <typename TTrack>
-  DGParticle(TDatabasePDG* pdg, DGAnaparHolder anaPars, TTrack const& tracks, std::vector<int> comb)
+  DGParticle(TDatabasePDG* pdg, const DGAnaparHolder& anaPars, TTrack const& tracks, const std::vector<int>& comb)
   {
     // compute invariant mass
     TLorentzVector lvtmp;
@@ -284,12 +285,12 @@ struct DGPIDSelector {
   ~DGPIDSelector();
 
   // setters
-  void init(DGAnaparHolder anaPars);
+  void init(const DGAnaparHolder& anaPars);
 
   // getters
   void Print();
   template <typename TTrack>
-  bool isGoodCombination(std::vector<int> comb, TTrack const& tracks, std::vector<int> acceptedCharges)
+  bool isGoodCombination(const std::vector<int>& comb, TTrack const& tracks, std::vector<int> acceptedCharges)
   {
     // compute net charge of track combination
     int netCharge = 0.;

PWGUD/Core/DGSelector.h

@@ -37,7 +37,7 @@ class DGSelector
   ~DGSelector() { delete fPDG; }
 
   template <typename CC, typename BCs, typename TCs, typename FWs>
-  int Print(DGCutparHolder /*diffCuts*/, CC& collision, BCs& /*bcRange*/, TCs& /*tracks*/, FWs& /*fwdtracks*/)
+  int Print(const DGCutparHolder& /*diffCuts*/, CC& collision, BCs& /*bcRange*/, TCs& /*tracks*/, FWs& /*fwdtracks*/)
   {
     LOGF(info, "Size of array %i", collision.size());
     return 1;

PWGUD/Core/SGCutParHolder.cxx

@@ -11,6 +11,7 @@
 
 #include "PWGUD/Core/SGCutParHolder.h"
 
+#include <utility>
 #include <vector>
 
 // setter
@@ -69,7 +70,7 @@ void SGCutParHolder::SetMaxFITtime(float maxFITtime)
 }
 void SGCutParHolder::SetFITAmpLimits(std::vector<float> FITAmpLimits)
 {
-  mFITAmpLimits = FITAmpLimits;
+  mFITAmpLimits = std::move(FITAmpLimits);
 }
 
 // getter

PWGUD/Core/SGCutParHolder.h

@@ -14,6 +14,7 @@
 
 #include <Rtypes.h>
 
+#include <utility>
 #include <vector>
 
 // object to hold customizable cut values
@@ -32,7 +33,7 @@ class SGCutParHolder
                  float minEta = -1.0, float maxEta = 1.0,
                  float maxFITtime = 4,
                  float minRgtrwTOF = 0.,
-                 std::vector<float> FITAmpLimits = {0., 0., 0., 0., 0.}) : mNDtcoll{ndtcoll}, mMinNBCs{nMinBCs}, mWithFwdTracks{withFwdTracks}, mGlobalTracksOnly{globalTracksOnly}, mITSOnlyTracks{ITSonlyTracks}, mMinNTracks{MinNTracks}, mMaxNTracks{MaxNTracks}, mPidHypo{pidHypo}, mMinVertexPosz{MinPosz}, mMaxVertexPosz{MaxPosz}, mMinPt{minPt}, mMaxPt{maxPt}, mMinEta{minEta}, mMaxEta{maxEta}, mMaxFITtime{maxFITtime}, mMinRgtrwTOF{minRgtrwTOF}, mFITAmpLimits{FITAmpLimits}
+                 std::vector<float> FITAmpLimits = {0., 0., 0., 0., 0.}) : mNDtcoll{ndtcoll}, mMinNBCs{nMinBCs}, mWithFwdTracks{withFwdTracks}, mGlobalTracksOnly{globalTracksOnly}, mITSOnlyTracks{ITSonlyTracks}, mMinNTracks{MinNTracks}, mMaxNTracks{MaxNTracks}, mPidHypo{pidHypo}, mMinVertexPosz{MinPosz}, mMaxVertexPosz{MaxPosz}, mMinPt{minPt}, mMaxPt{maxPt}, mMinEta{minEta}, mMaxEta{maxEta}, mMaxFITtime{maxFITtime}, mMinRgtrwTOF{minRgtrwTOF}, mFITAmpLimits{std::move(FITAmpLimits)}
   {
   }
 

PWGUD/Core/UDFSParser.cxx

@@ -138,8 +138,8 @@ bool UDFSParser::isNumber(std::string s)
 }
 
 // -----------------------------------------------------------------------------
-std::string UDFSParser::trim(std::string str,
-                             std::string whitespace = " \t")
+std::string UDFSParser::trim(const std::string& str,
+                             const std::string& whitespace = " \t")
 {
   const auto strBegin = str.find_first_not_of(whitespace);
   if (strBegin == std::string::npos)

PWGUD/Core/UDFSParser.h

@@ -60,7 +60,7 @@ class UDFSParser
 
   // helper functions for string parsing
   bool isNumber(std::string s);
-  std::string trim(std::string str, std::string whitespace);
+  std::string trim(const std::string& str, const std::string& whitespace);
   std::vector<std::string> tokenize(std::string& str, std::string separator = ",");
   bool isInVector(int num, std::vector<int> vec);
 

PWGUD/Core/UDGoodRunSelector.cxx

@@ -69,7 +69,7 @@ bool UDGoodRunSelector::isGoodRun(int runNumber)
   }
 }
 
-std::vector<int> UDGoodRunSelector::goodRuns(std::string runPeriod)
+std::vector<int> UDGoodRunSelector::goodRuns(const std::string& runPeriod)
 {
   auto it = mrunMap.find(runPeriod.c_str());
   if (it != mrunMap.end()) {

PWGUD/Core/UDGoodRunSelector.h

@@ -33,7 +33,7 @@ struct UDGoodRunSelector {
   void Print();
   bool isGoodRun(int runNumber);
   std::vector<int> goodRuns() { return mgoodRuns; }
-  std::vector<int> goodRuns(std::string runPeriod);
+  std::vector<int> goodRuns(const std::string& runPeriod);
   int rnumMin() { return mrnMin; }
   int rnumMax() { return mrnMax; }
 

PWGUD/Core/UDHelpers.h

@@ -243,7 +243,7 @@ T MCcompatibleBCs(F const& collision, int const& ndt, T const& bcs, int const& n
 // function to check if track provides good PID information
 // Checks the nSigma for any particle assumption to be within limits.
 template <typename TC>
-bool hasGoodPID(DGCutparHolder diffCuts, TC track)
+bool hasGoodPID(const DGCutparHolder& diffCuts, TC track)
 {
   // El, Mu, Pi, Ka, and Pr are considered
   // at least one nSigma must be within set limits
@@ -891,7 +891,7 @@ bool cleanCalo(T const& bc, o2::aod::Calos& calos, std::vector<float>& /*lims*/,
 // -----------------------------------------------------------------------------
 // check if all tracks come from same MCCollision
 template <typename T>
-int64_t sameMCCollision(T tracks, o2::aod::McCollisions, o2::aod::McParticles)
+int64_t sameMCCollision(T tracks, const o2::aod::McCollisions&, const o2::aod::McParticles&)
 {
   int64_t colID = -1;
   for (auto const& track : tracks) {

PWGUD/Core/UPCJpsiCentralBarrelCorrHelper.h

@@ -213,7 +213,7 @@ float* correlation(TLorentzVector* lv1, TLorentzVector* lv2, TLorentzVector* lv)
   return q;
 }
 
-double DeltaPhi(TLorentzVector lv1, TLorentzVector lv2)
+double DeltaPhi(const TLorentzVector& lv1, const TLorentzVector& lv2)
 {
   TLorentzVector lv_sum = lv1 + lv2;
   TLorentzVector lv_diff = lv1 - lv2;
@@ -223,7 +223,7 @@ double DeltaPhi(TLorentzVector lv1, TLorentzVector lv2)
   return dp;
 }
 
-double DeltaPhiRandom(TLorentzVector lv1, TLorentzVector lv2)
+double DeltaPhiRandom(const TLorentzVector& lv1, const TLorentzVector& lv2)
 {
   std::vector<int> indices = {0, 1};
   unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();

PWGUD/Core/UPCTauCentralBarrelHelperRL.h

@@ -52,19 +52,19 @@ enum MyTauChannel {
   CH_ENUM_COUNTER = 11
 };
 
-void printLargeMessage(std::string info)
+void printLargeMessage(const std::string& info)
 // Helper to printf info message to terminal
 {
   LOGF(info, "################################### %s ###################################", info);
 }
 
-void printMediumMessage(std::string info)
+void printMediumMessage(const std::string& info)
 // Helper to printf info message to terminal
 {
   LOGF(info, "+++++++++++++ %s +++++++++++++", info);
 }
 
-void printDebugMessage(std::string info)
+void printDebugMessage(const std::string& info)
 // Helper to printf info message to terminal
 {
   LOGF(debug, "X!X!X!X!X!X!X!X!X %s X!X!X!X!X!X!X!X!X", info);

PWGUD/Core/decayTree.cxx

@@ -93,7 +93,7 @@ void pidSelector::Print()
 // angleCut
 angleCut::angleCut(std::pair<std::string, std::string> rnames, double angleMin, double angleMax)
 {
-  fRnames = rnames;
+  fRnames = std::move(rnames);
   fAngleMin = angleMin;
   fAngleMax = angleMax;
 }
@@ -982,7 +982,7 @@ void decayTree::Print()
   }
 }
 
-resonance* decayTree::getResonance(std::string name)
+resonance* decayTree::getResonance(const std::string& name)
 {
   for (const auto& res : fResonances) {
     if (res->name() == name) {