[PWGCF] Fix indexing between track and collision tables (#13793)

abmodak · web-flow · commit 521d836f3bc3 · 2025-11-12T17:19:21.000+01:00
diff --git a/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx b/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx
@@ -46,6 +46,7 @@
 #include "Framework/AnalysisTask.h"
 #include "Framework/HistogramRegistry.h"
 #include "Framework/O2DatabasePDGPlugin.h"
+#include "Framework/RunningWorkflowInfo.h"
 #include "Framework/StepTHn.h"
 #include "Framework/runDataProcessing.h"
 #include "ReconstructionDataFormats/PID.h"
@@ -58,7 +59,10 @@
 
 #include <chrono>
 #include <cstdio>
+#include <experimental/type_traits>
+#include <memory>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -74,7 +78,6 @@ struct LongrangecorrDerived {
 
   SliceCache cache;
   HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject};
-  Configurable<double> cfgSampleSize{"cfgSampleSize", 10, "Sample size for mixed event"};
   Configurable<int> cfgNmixedevent{"cfgNmixedevent", 5, "how many events are mixed"};
   Configurable<int> cfgPidMask{"cfgPidMask", 0, "Selection bitmask for the TPC particle"};
   Configurable<int> cfgV0Mask{"cfgV0Mask", 0, "Selection bitmask for the V0 particle"};
@@ -85,10 +88,7 @@ struct LongrangecorrDerived {
   ConfigurableAxis axisEtaTrig{"axisEtaTrig", {40, -1., 1.}, "#eta trig axis"};
   ConfigurableAxis axisPtTrigger{"axisPtTrigger", {VARIABLE_WIDTH, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, 10.0}, "pt trigger axis for histograms"};
   ConfigurableAxis axisPtAssoc{"axisPtAssoc", {VARIABLE_WIDTH, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, 10.0}, "pt assoc axis for histograms"};
-  ConfigurableAxis axisSample{"axisSample", {cfgSampleSize, 0, cfgSampleSize}, "sample axis for histograms"};
   ConfigurableAxis axisVtxZ{"axisVtxZ", {40, -20, 20}, "vertex axis"};
-  ConfigurableAxis channelFt0aAxis{"channelFt0aAxis", {96, 0.0, 96.0}, "FT0A channel"};
-  ConfigurableAxis amplitudeFt0a{"amplitudeFt0a", {5000, 0, 10000}, "FT0A amplitude"};
   ConfigurableAxis axisEtaAssoc{"axisEtaAssoc", {96, 3.5, 4.9}, "#eta assoc axis"};
   ConfigurableAxis axisDeltaPhi{"axisDeltaPhi", {72, -PIHalf, PIHalf * 3}, "delta phi axis for histograms"};
   ConfigurableAxis axisDeltaEta{"axisDeltaEta", {40, -6, -2}, "delta eta axis for histograms"};
@@ -103,19 +103,33 @@ struct LongrangecorrDerived {
   OutputObj<CorrelationContainer> same{"sameEvent"};
   OutputObj<CorrelationContainer> mixed{"mixedEvent"};
 
+  using CollsTable = aod::CollLRTables;
+  using TrksTable = aod::TrkLRTables;
+  using MftTrksTable = aod::MftTrkLRTables;
+  using Ft0aTrksTable = aod::Ft0aLRTables;
+  using Ft0cTrksTable = aod::Ft0cLRTables;
+  using MftbestTrksTable = aod::MftBestTrkLRTables;
+  using V0TrksTable = aod::V0TrkLRTables;
+
+  Preslice<TrksTable> perColTpc = aod::lrcorrtrktable::collLRTableId;
+  Preslice<MftTrksTable> perColMft = aod::lrcorrtrktable::collLRTableId;
+  Preslice<MftbestTrksTable> perColMftbest = aod::lrcorrtrktable::collLRTableId;
+  Preslice<Ft0aTrksTable> perColFt0a = aod::lrcorrtrktable::collLRTableId;
+  Preslice<Ft0cTrksTable> perColFt0c = aod::lrcorrtrktable::collLRTableId;
+  Preslice<V0TrksTable> perColV0 = aod::lrcorrtrktable::collLRTableId;
+
   void init(InitContext const&)
   {
-    std::vector<AxisSpec> corrAxis = {{axisSample, "Sample"},
-                                      {axisVtxZ, "z-vtx (cm)"},
+    std::vector<AxisSpec> corrAxis = {{axisVtxZ, "z-vtx (cm)"},
+                                      {axisMultiplicity, "multiplicity"},
                                       {axisPtTrigger, "p_{T} (GeV/c)"},
                                       {axisPtAssoc, "p_{T} (GeV/c)"},
                                       {axisDeltaPhi, "#Delta#varphi (rad)"},
                                       {axisDeltaEta, "#Delta#eta"}};
     std::vector<AxisSpec> effAxis = {{axisVertexEfficiency, "z-vtx (cm)"},
                                      {axisPtEfficiency, "p_{T} (GeV/c)"},
                                      {axisEtaEfficiency, "#eta"}};
-    std::vector<AxisSpec> userAxis = {{axisMultiplicity, "multiplicity"},
-                                      {axisInvMass, "m (GeV/c^2)"}};
+    std::vector<AxisSpec> userAxis = {{axisInvMass, "m (GeV/c^2)"}};
 
     same.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, userAxis));
     mixed.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, userAxis));
@@ -128,7 +142,7 @@ struct LongrangecorrDerived {
     histos.add("Trig_phi", "Trig_phi", kTH1D, {axisPhi});
     histos.add("Trig_etavsphi", "Trig_etavsphi", kTH2D, {axisPhi, axisEtaTrig});
     histos.add("Trig_pt", "Trig_pt", kTH1D, {axisPtTrigger});
-    histos.add("Trig_hist", "Trig_hist", kTHnSparseF, {axisSample, axisVtxZ, axisPtTrigger, axisMultiplicity, axisInvMass});
+    histos.add("Trig_hist", "Trig_hist", kTHnSparseF, {axisVtxZ, axisMultiplicity, axisPtTrigger, axisInvMass});
 
     histos.add("Assoc_eta", "Assoc_eta", kTH1D, {axisEtaAssoc});
     histos.add("Assoc_phi", "Assoc_phi", kTH1D, {axisPhi});
@@ -174,7 +188,6 @@ struct LongrangecorrDerived {
   template <CorrelationContainer::CFStep step, typename TTarget, typename TTriggers, typename TAssocs>
   void fillCorrHist(TTarget target, TTriggers const& triggers, TAssocs const& assocs, bool mixing, float vz, float multiplicity, float eventWeight)
   {
-    int fSampleIndex = gRandom->Uniform(0, cfgSampleSize);
     for (auto const& triggerTrack : triggers) {
       if constexpr (std::experimental::is_detected<HasTpcTrack, typename TTriggers::iterator>::value) {
         if (cfgPidMask != 0 && (cfgPidMask & (1u << static_cast<uint32_t>(triggerTrack.trackType()))) == 0u)
@@ -186,9 +199,9 @@ struct LongrangecorrDerived {
       if (!mixing) {
         fillTrigTrackQA(triggerTrack);
         if constexpr (std::experimental::is_detected<HasInvMass, typename TTriggers::iterator>::value) {
-          histos.fill(HIST("Trig_hist"), fSampleIndex, vz, triggerTrack.pt(), multiplicity, triggerTrack.invMass(), eventWeight);
+          histos.fill(HIST("Trig_hist"), vz, multiplicity, triggerTrack.pt(), triggerTrack.invMass(), eventWeight);
         } else {
-          histos.fill(HIST("Trig_hist"), fSampleIndex, vz, triggerTrack.pt(), multiplicity, 1.0, eventWeight);
+          histos.fill(HIST("Trig_hist"), vz, multiplicity, triggerTrack.pt(), 1.0, eventWeight);
         }
       }
       for (auto const& assoTrack : assocs) {
@@ -201,9 +214,9 @@ struct LongrangecorrDerived {
           histos.fill(HIST("deltaEta_deltaPhi_mixed"), deltaPhi, deltaEta);
         }
         if constexpr (std::experimental::is_detected<HasInvMass, typename TTriggers::iterator>::value) {
-          target->getPairHist()->Fill(step, fSampleIndex, vz, triggerTrack.pt(), triggerTrack.pt(), deltaPhi, deltaEta, multiplicity, triggerTrack.invMass(), eventWeight);
+          target->getPairHist()->Fill(step, vz, multiplicity, triggerTrack.pt(), triggerTrack.pt(), deltaPhi, deltaEta, triggerTrack.invMass(), eventWeight);
         } else {
-          target->getPairHist()->Fill(step, fSampleIndex, vz, triggerTrack.pt(), triggerTrack.pt(), deltaPhi, deltaEta, multiplicity, 0., eventWeight);
+          target->getPairHist()->Fill(step, vz, multiplicity, triggerTrack.pt(), triggerTrack.pt(), deltaPhi, deltaEta, 1.0, eventWeight);
         }
       } // associated tracks
     } // trigger tracks
@@ -239,94 +252,94 @@ struct LongrangecorrDerived {
     } // pair loop
   } // process mixed
 
-  void processTpcft0aSE(aod::CollLRTables::iterator const& col, aod::TrkLRTables const& tracks, aod::Ft0aLRTables const& ft0as)
+  void processTpcft0aSE(CollsTable::iterator const& col, TrksTable const& tracks, Ft0aTrksTable const& ft0as)
   {
     processSame(col, tracks, ft0as);
   }
 
-  void processTpcft0cSE(aod::CollLRTables::iterator const& col, aod::TrkLRTables const& tracks, aod::Ft0cLRTables const& ft0cs)
+  void processTpcft0cSE(CollsTable::iterator const& col, TrksTable const& tracks, Ft0cTrksTable const& ft0cs)
   {
     processSame(col, tracks, ft0cs);
   }
 
-  void processTpcmftSE(aod::CollLRTables::iterator const& col, aod::TrkLRTables const& tracks, aod::MftTrkLRTables const& mfts)
+  void processTpcmftSE(CollsTable::iterator const& col, TrksTable const& tracks, MftTrksTable const& mfts)
   {
     processSame(col, tracks, mfts);
   }
 
-  void processMftft0aSE(aod::CollLRTables::iterator const& col, aod::MftTrkLRTables const& mfts, aod::Ft0aLRTables const& ft0as)
+  void processMftft0aSE(CollsTable::iterator const& col, MftTrksTable const& mfts, Ft0aTrksTable const& ft0as)
   {
     processSame(col, mfts, ft0as);
   }
 
-  void processV0ft0aSE(aod::CollLRTables::iterator const& col, aod::V0TrkLRTables const& tracks, aod::Ft0aLRTables const& ft0as)
+  void processV0ft0aSE(CollsTable::iterator const& col, V0TrksTable const& tracks, Ft0aTrksTable const& ft0as)
   {
     processSame(col, tracks, ft0as);
   }
 
-  void processV0mftSE(aod::CollLRTables::iterator const& col, aod::V0TrkLRTables const& tracks, aod::MftTrkLRTables const& mfts)
+  void processV0mftSE(CollsTable::iterator const& col, V0TrksTable const& tracks, MftTrksTable const& mfts)
   {
     processSame(col, tracks, mfts);
   }
 
-  void processTpcmftbestSE(aod::CollLRTables::iterator const& col, aod::TrkLRTables const& tracks, aod::MftBestTrkLRTables const& mfts)
+  void processTpcmftbestSE(CollsTable::iterator const& col, TrksTable const& tracks, MftbestTrksTable const& mfts)
   {
     processSame(col, tracks, mfts);
   }
 
-  void processMftbestft0aSE(aod::CollLRTables::iterator const& col, aod::MftBestTrkLRTables const& mfts, aod::Ft0aLRTables const& ft0as)
+  void processMftbestft0aSE(CollsTable::iterator const& col, MftbestTrksTable const& mfts, Ft0aTrksTable const& ft0as)
   {
     processSame(col, mfts, ft0as);
   }
 
-  void processV0mftbestSE(aod::CollLRTables::iterator const& col, aod::V0TrkLRTables const& tracks, aod::MftBestTrkLRTables const& mfts)
+  void processV0mftbestSE(CollsTable::iterator const& col, V0TrksTable const& tracks, MftbestTrksTable const& mfts)
   {
     processSame(col, tracks, mfts);
   }
 
-  void processTpcft0aME(aod::CollLRTables const& col, aod::TrkLRTables const& tracks, aod::Ft0aLRTables const& ft0as)
+  void processTpcft0aME(CollsTable const& cols, TrksTable const& tracks, Ft0aTrksTable const& ft0as)
   {
-    processMixed(col, tracks, ft0as);
+    processMixed(cols, tracks, ft0as);
   }
 
-  void processTpcft0cME(aod::CollLRTables const& col, aod::TrkLRTables const& tracks, aod::Ft0cLRTables const& ft0cs)
+  void processTpcft0cME(CollsTable const& cols, TrksTable const& tracks, Ft0cTrksTable const& ft0cs)
   {
-    processMixed(col, tracks, ft0cs);
+    processMixed(cols, tracks, ft0cs);
   }
 
-  void processTpcmftME(aod::CollLRTables const& col, aod::TrkLRTables const& tracks, aod::MftTrkLRTables const& mfts)
+  void processTpcmftME(CollsTable const& cols, TrksTable const& tracks, MftTrksTable const& mfts)
   {
-    processMixed(col, tracks, mfts);
+    processMixed(cols, tracks, mfts);
   }
 
-  void processMftft0aME(aod::CollLRTables const& col, aod::MftTrkLRTables const& mfts, aod::Ft0aLRTables const& ft0as)
+  void processMftft0aME(CollsTable const& cols, MftTrksTable const& mfts, Ft0aTrksTable const& ft0as)
   {
-    processMixed(col, mfts, ft0as);
+    processMixed(cols, mfts, ft0as);
   }
 
-  void processV0ft0aME(aod::CollLRTables const& col, aod::V0TrkLRTables const& tracks, aod::Ft0aLRTables const& ft0as)
+  void processV0ft0aME(CollsTable const& cols, V0TrksTable const& tracks, Ft0aTrksTable const& ft0as)
   {
-    processMixed(col, tracks, ft0as);
+    processMixed(cols, tracks, ft0as);
   }
 
-  void processV0mftME(aod::CollLRTables const& col, aod::V0TrkLRTables const& tracks, aod::MftTrkLRTables const& mfts)
+  void processV0mftME(CollsTable const& cols, V0TrksTable const& tracks, MftTrksTable const& mfts)
   {
-    processMixed(col, tracks, mfts);
+    processMixed(cols, tracks, mfts);
   }
 
-  void processTpcmftbestME(aod::CollLRTables const& col, aod::TrkLRTables const& tracks, aod::MftBestTrkLRTables const& mfts)
+  void processTpcmftbestME(CollsTable const& cols, TrksTable const& tracks, MftbestTrksTable const& mfts)
   {
-    processMixed(col, tracks, mfts);
+    processMixed(cols, tracks, mfts);
   }
 
-  void processMftbestft0aME(aod::CollLRTables const& col, aod::MftBestTrkLRTables const& mfts, aod::Ft0aLRTables const& ft0as)
+  void processMftbestft0aME(CollsTable const& cols, MftbestTrksTable const& mfts, Ft0aTrksTable const& ft0as)
   {
-    processMixed(col, mfts, ft0as);
+    processMixed(cols, mfts, ft0as);
   }
 
-  void processV0mftbestME(aod::CollLRTables const& col, aod::V0TrkLRTables const& tracks, aod::MftBestTrkLRTables const& mfts)
+  void processV0mftbestME(CollsTable const& cols, V0TrksTable const& tracks, MftbestTrksTable const& mfts)
   {
-    processMixed(col, tracks, mfts);
+    processMixed(cols, tracks, mfts);
   }
 
   PROCESS_SWITCH(LongrangecorrDerived, processTpcft0aSE, "same event TPC vs FT0A", false);

Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,7 @@`
`46`	`46`	`#include "Framework/AnalysisTask.h"`
`47`	`47`	`#include "Framework/HistogramRegistry.h"`
`48`	`48`	`#include "Framework/O2DatabasePDGPlugin.h"`
	`49`	`+#include "Framework/RunningWorkflowInfo.h"`
`49`	`50`	`#include "Framework/StepTHn.h"`
`50`	`51`	`#include "Framework/runDataProcessing.h"`
`51`	`52`	`#include "ReconstructionDataFormats/PID.h"`
`@@ -58,7 +59,10 @@`
`58`	`59`
`59`	`60`	`#include <chrono>`
`60`	`61`	`#include <cstdio>`
	`62`	`+#include <experimental/type_traits>`
	`63`	`+#include <memory>`
`61`	`64`	`#include <string>`
	`65`	`+#include <tuple>`
`62`	`66`	`#include <utility>`
`63`	`67`	`#include <vector>`
`64`	`68`
`@@ -74,7 +78,6 @@ struct LongrangecorrDerived {`
`74`	`78`
`75`	`79`	`SliceCache cache;`
`76`	`80`	`HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject};`
`77`		`- Configurable<double> cfgSampleSize{"cfgSampleSize", 10, "Sample size for mixed event"};`
`78`	`81`	`Configurable<int> cfgNmixedevent{"cfgNmixedevent", 5, "how many events are mixed"};`
`79`	`82`	`Configurable<int> cfgPidMask{"cfgPidMask", 0, "Selection bitmask for the TPC particle"};`
`80`	`83`	`Configurable<int> cfgV0Mask{"cfgV0Mask", 0, "Selection bitmask for the V0 particle"};`
`@@ -85,10 +88,7 @@ struct LongrangecorrDerived {`
`85`	`88`	`ConfigurableAxis axisEtaTrig{"axisEtaTrig", {40, -1., 1.}, "#eta trig axis"};`
`86`	`89`	`ConfigurableAxis axisPtTrigger{"axisPtTrigger", {VARIABLE_WIDTH, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, 10.0}, "pt trigger axis for histograms"};`
`87`	`90`	`ConfigurableAxis axisPtAssoc{"axisPtAssoc", {VARIABLE_WIDTH, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, 10.0}, "pt assoc axis for histograms"};`
`88`		`- ConfigurableAxis axisSample{"axisSample", {cfgSampleSize, 0, cfgSampleSize}, "sample axis for histograms"};`
`89`	`91`	`ConfigurableAxis axisVtxZ{"axisVtxZ", {40, -20, 20}, "vertex axis"};`
`90`		`- ConfigurableAxis channelFt0aAxis{"channelFt0aAxis", {96, 0.0, 96.0}, "FT0A channel"};`
`91`		`- ConfigurableAxis amplitudeFt0a{"amplitudeFt0a", {5000, 0, 10000}, "FT0A amplitude"};`
`92`	`92`	`ConfigurableAxis axisEtaAssoc{"axisEtaAssoc", {96, 3.5, 4.9}, "#eta assoc axis"};`
`93`	`93`	`ConfigurableAxis axisDeltaPhi{"axisDeltaPhi", {72, -PIHalf, PIHalf * 3}, "delta phi axis for histograms"};`
`94`	`94`	`ConfigurableAxis axisDeltaEta{"axisDeltaEta", {40, -6, -2}, "delta eta axis for histograms"};`
`@@ -103,19 +103,33 @@ struct LongrangecorrDerived {`
`103`	`103`	`OutputObj<CorrelationContainer> same{"sameEvent"};`
`104`	`104`	`OutputObj<CorrelationContainer> mixed{"mixedEvent"};`
`105`	`105`
	`106`	`+ using CollsTable = aod::CollLRTables;`
	`107`	`+ using TrksTable = aod::TrkLRTables;`
	`108`	`+ using MftTrksTable = aod::MftTrkLRTables;`
	`109`	`+ using Ft0aTrksTable = aod::Ft0aLRTables;`
	`110`	`+ using Ft0cTrksTable = aod::Ft0cLRTables;`
	`111`	`+ using MftbestTrksTable = aod::MftBestTrkLRTables;`
	`112`	`+ using V0TrksTable = aod::V0TrkLRTables;`
	`113`	`+`
	`114`	`+ Preslice<TrksTable> perColTpc = aod::lrcorrtrktable::collLRTableId;`
	`115`	`+ Preslice<MftTrksTable> perColMft = aod::lrcorrtrktable::collLRTableId;`
	`116`	`+ Preslice<MftbestTrksTable> perColMftbest = aod::lrcorrtrktable::collLRTableId;`
	`117`	`+ Preslice<Ft0aTrksTable> perColFt0a = aod::lrcorrtrktable::collLRTableId;`
	`118`	`+ Preslice<Ft0cTrksTable> perColFt0c = aod::lrcorrtrktable::collLRTableId;`
	`119`	`+ Preslice<V0TrksTable> perColV0 = aod::lrcorrtrktable::collLRTableId;`
	`120`	`+`
`106`	`121`	`void init(InitContext const&)`
`107`	`122`	`{`
`108`		`- std::vector<AxisSpec> corrAxis = {{axisSample, "Sample"},`
`109`		`- {axisVtxZ, "z-vtx (cm)"},`
	`123`	`+ std::vector<AxisSpec> corrAxis = {{axisVtxZ, "z-vtx (cm)"},`
	`124`	`+ {axisMultiplicity, "multiplicity"},`
`110`	`125`	`{axisPtTrigger, "p_{T} (GeV/c)"},`
`111`	`126`	`{axisPtAssoc, "p_{T} (GeV/c)"},`
`112`	`127`	`{axisDeltaPhi, "#Delta#varphi (rad)"},`
`113`	`128`	`{axisDeltaEta, "#Delta#eta"}};`
`114`	`129`	`std::vector<AxisSpec> effAxis = {{axisVertexEfficiency, "z-vtx (cm)"},`
`115`	`130`	`{axisPtEfficiency, "p_{T} (GeV/c)"},`
`116`	`131`	`{axisEtaEfficiency, "#eta"}};`
`117`		`- std::vector<AxisSpec> userAxis = {{axisMultiplicity, "multiplicity"},`
`118`		`- {axisInvMass, "m (GeV/c^2)"}};`
	`132`	`+ std::vector<AxisSpec> userAxis = {{axisInvMass, "m (GeV/c^2)"}};`
`119`	`133`
`120`	`134`	`same.setObject(new CorrelationContainer("sameEvent", "sameEvent", corrAxis, effAxis, userAxis));`
`121`	`135`	`mixed.setObject(new CorrelationContainer("mixedEvent", "mixedEvent", corrAxis, effAxis, userAxis));`
`@@ -128,7 +142,7 @@ struct LongrangecorrDerived {`
`128`	`142`	`histos.add("Trig_phi", "Trig_phi", kTH1D, {axisPhi});`
`129`	`143`	`histos.add("Trig_etavsphi", "Trig_etavsphi", kTH2D, {axisPhi, axisEtaTrig});`
`130`	`144`	`histos.add("Trig_pt", "Trig_pt", kTH1D, {axisPtTrigger});`
`131`		`- histos.add("Trig_hist", "Trig_hist", kTHnSparseF, {axisSample, axisVtxZ, axisPtTrigger, axisMultiplicity, axisInvMass});`
	`145`	`+ histos.add("Trig_hist", "Trig_hist", kTHnSparseF, {axisVtxZ, axisMultiplicity, axisPtTrigger, axisInvMass});`
`132`	`146`
`133`	`147`	`histos.add("Assoc_eta", "Assoc_eta", kTH1D, {axisEtaAssoc});`
`134`	`148`	`histos.add("Assoc_phi", "Assoc_phi", kTH1D, {axisPhi});`
`@@ -174,7 +188,6 @@ struct LongrangecorrDerived {`
`174`	`188`	`template <CorrelationContainer::CFStep step, typename TTarget, typename TTriggers, typename TAssocs>`
`175`	`189`	`void fillCorrHist(TTarget target, TTriggers const& triggers, TAssocs const& assocs, bool mixing, float vz, float multiplicity, float eventWeight)`
`176`	`190`	`{`
`177`		`- int fSampleIndex = gRandom->Uniform(0, cfgSampleSize);`
`178`	`191`	`for (auto const& triggerTrack : triggers) {`
`179`	`192`	`if constexpr (std::experimental::is_detected<HasTpcTrack, typename TTriggers::iterator>::value) {`
`180`	`193`	`if (cfgPidMask != 0 && (cfgPidMask & (1u << static_cast<uint32_t>(triggerTrack.trackType()))) == 0u)`
`@@ -186,9 +199,9 @@ struct LongrangecorrDerived {`
`186`	`199`	`if (!mixing) {`
`187`	`200`	`fillTrigTrackQA(triggerTrack);`
`188`	`201`	`if constexpr (std::experimental::is_detected<HasInvMass, typename TTriggers::iterator>::value) {`
`189`		`- histos.fill(HIST("Trig_hist"), fSampleIndex, vz, triggerTrack.pt(), multiplicity, triggerTrack.invMass(), eventWeight);`
	`202`	`+ histos.fill(HIST("Trig_hist"), vz, multiplicity, triggerTrack.pt(), triggerTrack.invMass(), eventWeight);`
`190`	`203`	`} else {`
`191`		`- histos.fill(HIST("Trig_hist"), fSampleIndex, vz, triggerTrack.pt(), multiplicity, 1.0, eventWeight);`
	`204`	`+ histos.fill(HIST("Trig_hist"), vz, multiplicity, triggerTrack.pt(), 1.0, eventWeight);`
`192`	`205`	`}`
`193`	`206`	`}`
`194`	`207`	`for (auto const& assoTrack : assocs) {`
`@@ -201,9 +214,9 @@ struct LongrangecorrDerived {`
`201`	`214`	`histos.fill(HIST("deltaEta_deltaPhi_mixed"), deltaPhi, deltaEta);`
`202`	`215`	`}`
`203`	`216`	`if constexpr (std::experimental::is_detected<HasInvMass, typename TTriggers::iterator>::value) {`
`204`		`- target->getPairHist()->Fill(step, fSampleIndex, vz, triggerTrack.pt(), triggerTrack.pt(), deltaPhi, deltaEta, multiplicity, triggerTrack.invMass(), eventWeight);`
	`217`	`+ target->getPairHist()->Fill(step, vz, multiplicity, triggerTrack.pt(), triggerTrack.pt(), deltaPhi, deltaEta, triggerTrack.invMass(), eventWeight);`
`205`	`218`	`} else {`
`206`		`- target->getPairHist()->Fill(step, fSampleIndex, vz, triggerTrack.pt(), triggerTrack.pt(), deltaPhi, deltaEta, multiplicity, 0., eventWeight);`
	`219`	`+ target->getPairHist()->Fill(step, vz, multiplicity, triggerTrack.pt(), triggerTrack.pt(), deltaPhi, deltaEta, 1.0, eventWeight);`
`207`	`220`	`}`
`208`	`221`	`} // associated tracks`
`209`	`222`	`} // trigger tracks`
`@@ -239,94 +252,94 @@ struct LongrangecorrDerived {`
`239`	`252`	`} // pair loop`
`240`	`253`	`} // process mixed`
`241`	`254`
`242`		`- void processTpcft0aSE(aod::CollLRTables::iterator const& col, aod::TrkLRTables const& tracks, aod::Ft0aLRTables const& ft0as)`
	`255`	`+ void processTpcft0aSE(CollsTable::iterator const& col, TrksTable const& tracks, Ft0aTrksTable const& ft0as)`
`243`	`256`	`{`
`244`	`257`	`processSame(col, tracks, ft0as);`
`245`	`258`	`}`
`246`	`259`
`247`		`- void processTpcft0cSE(aod::CollLRTables::iterator const& col, aod::TrkLRTables const& tracks, aod::Ft0cLRTables const& ft0cs)`
	`260`	`+ void processTpcft0cSE(CollsTable::iterator const& col, TrksTable const& tracks, Ft0cTrksTable const& ft0cs)`
`248`	`261`	`{`
`249`	`262`	`processSame(col, tracks, ft0cs);`
`250`	`263`	`}`
`251`	`264`
`252`		`- void processTpcmftSE(aod::CollLRTables::iterator const& col, aod::TrkLRTables const& tracks, aod::MftTrkLRTables const& mfts)`
	`265`	`+ void processTpcmftSE(CollsTable::iterator const& col, TrksTable const& tracks, MftTrksTable const& mfts)`
`253`	`266`	`{`
`254`	`267`	`processSame(col, tracks, mfts);`
`255`	`268`	`}`
`256`	`269`
`257`		`- void processMftft0aSE(aod::CollLRTables::iterator const& col, aod::MftTrkLRTables const& mfts, aod::Ft0aLRTables const& ft0as)`
	`270`	`+ void processMftft0aSE(CollsTable::iterator const& col, MftTrksTable const& mfts, Ft0aTrksTable const& ft0as)`
`258`	`271`	`{`
`259`	`272`	`processSame(col, mfts, ft0as);`
`260`	`273`	`}`
`261`	`274`
`262`		`- void processV0ft0aSE(aod::CollLRTables::iterator const& col, aod::V0TrkLRTables const& tracks, aod::Ft0aLRTables const& ft0as)`
	`275`	`+ void processV0ft0aSE(CollsTable::iterator const& col, V0TrksTable const& tracks, Ft0aTrksTable const& ft0as)`
`263`	`276`	`{`
`264`	`277`	`processSame(col, tracks, ft0as);`
`265`	`278`	`}`
`266`	`279`
`267`		`- void processV0mftSE(aod::CollLRTables::iterator const& col, aod::V0TrkLRTables const& tracks, aod::MftTrkLRTables const& mfts)`
	`280`	`+ void processV0mftSE(CollsTable::iterator const& col, V0TrksTable const& tracks, MftTrksTable const& mfts)`
`268`	`281`	`{`
`269`	`282`	`processSame(col, tracks, mfts);`
`270`	`283`	`}`
`271`	`284`
`272`		`- void processTpcmftbestSE(aod::CollLRTables::iterator const& col, aod::TrkLRTables const& tracks, aod::MftBestTrkLRTables const& mfts)`
	`285`	`+ void processTpcmftbestSE(CollsTable::iterator const& col, TrksTable const& tracks, MftbestTrksTable const& mfts)`
`273`	`286`	`{`
`274`	`287`	`processSame(col, tracks, mfts);`
`275`	`288`	`}`
`276`	`289`
`277`		`- void processMftbestft0aSE(aod::CollLRTables::iterator const& col, aod::MftBestTrkLRTables const& mfts, aod::Ft0aLRTables const& ft0as)`
	`290`	`+ void processMftbestft0aSE(CollsTable::iterator const& col, MftbestTrksTable const& mfts, Ft0aTrksTable const& ft0as)`
`278`	`291`	`{`
`279`	`292`	`processSame(col, mfts, ft0as);`
`280`	`293`	`}`
`281`	`294`
`282`		`- void processV0mftbestSE(aod::CollLRTables::iterator const& col, aod::V0TrkLRTables const& tracks, aod::MftBestTrkLRTables const& mfts)`
	`295`	`+ void processV0mftbestSE(CollsTable::iterator const& col, V0TrksTable const& tracks, MftbestTrksTable const& mfts)`
`283`	`296`	`{`
`284`	`297`	`processSame(col, tracks, mfts);`
`285`	`298`	`}`
`286`	`299`
`287`		`- void processTpcft0aME(aod::CollLRTables const& col, aod::TrkLRTables const& tracks, aod::Ft0aLRTables const& ft0as)`
	`300`	`+ void processTpcft0aME(CollsTable const& cols, TrksTable const& tracks, Ft0aTrksTable const& ft0as)`
`288`	`301`	`{`
`289`		`- processMixed(col, tracks, ft0as);`
	`302`	`+ processMixed(cols, tracks, ft0as);`
`290`	`303`	`}`
`291`	`304`
`292`		`- void processTpcft0cME(aod::CollLRTables const& col, aod::TrkLRTables const& tracks, aod::Ft0cLRTables const& ft0cs)`
	`305`	`+ void processTpcft0cME(CollsTable const& cols, TrksTable const& tracks, Ft0cTrksTable const& ft0cs)`
`293`	`306`	`{`
`294`		`- processMixed(col, tracks, ft0cs);`
	`307`	`+ processMixed(cols, tracks, ft0cs);`
`295`	`308`	`}`
`296`	`309`
`297`		`- void processTpcmftME(aod::CollLRTables const& col, aod::TrkLRTables const& tracks, aod::MftTrkLRTables const& mfts)`
	`310`	`+ void processTpcmftME(CollsTable const& cols, TrksTable const& tracks, MftTrksTable const& mfts)`
`298`	`311`	`{`
`299`		`- processMixed(col, tracks, mfts);`
	`312`	`+ processMixed(cols, tracks, mfts);`
`300`	`313`	`}`
`301`	`314`
`302`		`- void processMftft0aME(aod::CollLRTables const& col, aod::MftTrkLRTables const& mfts, aod::Ft0aLRTables const& ft0as)`
	`315`	`+ void processMftft0aME(CollsTable const& cols, MftTrksTable const& mfts, Ft0aTrksTable const& ft0as)`
`303`	`316`	`{`
`304`		`- processMixed(col, mfts, ft0as);`
	`317`	`+ processMixed(cols, mfts, ft0as);`
`305`	`318`	`}`
`306`	`319`
`307`		`- void processV0ft0aME(aod::CollLRTables const& col, aod::V0TrkLRTables const& tracks, aod::Ft0aLRTables const& ft0as)`
	`320`	`+ void processV0ft0aME(CollsTable const& cols, V0TrksTable const& tracks, Ft0aTrksTable const& ft0as)`
`308`	`321`	`{`
`309`		`- processMixed(col, tracks, ft0as);`
	`322`	`+ processMixed(cols, tracks, ft0as);`
`310`	`323`	`}`
`311`	`324`
`312`		`- void processV0mftME(aod::CollLRTables const& col, aod::V0TrkLRTables const& tracks, aod::MftTrkLRTables const& mfts)`
	`325`	`+ void processV0mftME(CollsTable const& cols, V0TrksTable const& tracks, MftTrksTable const& mfts)`
`313`	`326`	`{`
`314`		`- processMixed(col, tracks, mfts);`
	`327`	`+ processMixed(cols, tracks, mfts);`
`315`	`328`	`}`
`316`	`329`
`317`		`- void processTpcmftbestME(aod::CollLRTables const& col, aod::TrkLRTables const& tracks, aod::MftBestTrkLRTables const& mfts)`
	`330`	`+ void processTpcmftbestME(CollsTable const& cols, TrksTable const& tracks, MftbestTrksTable const& mfts)`
`318`	`331`	`{`
`319`		`- processMixed(col, tracks, mfts);`
	`332`	`+ processMixed(cols, tracks, mfts);`
`320`	`333`	`}`
`321`	`334`
`322`		`- void processMftbestft0aME(aod::CollLRTables const& col, aod::MftBestTrkLRTables const& mfts, aod::Ft0aLRTables const& ft0as)`
	`335`	`+ void processMftbestft0aME(CollsTable const& cols, MftbestTrksTable const& mfts, Ft0aTrksTable const& ft0as)`
`323`	`336`	`{`
`324`		`- processMixed(col, mfts, ft0as);`
	`337`	`+ processMixed(cols, mfts, ft0as);`
`325`	`338`	`}`
`326`	`339`
`327`		`- void processV0mftbestME(aod::CollLRTables const& col, aod::V0TrkLRTables const& tracks, aod::MftBestTrkLRTables const& mfts)`
	`340`	`+ void processV0mftbestME(CollsTable const& cols, V0TrksTable const& tracks, MftbestTrksTable const& mfts)`
`328`	`341`	`{`
`329`		`- processMixed(col, tracks, mfts);`
	`342`	`+ processMixed(cols, tracks, mfts);`
`330`	`343`	`}`
`331`	`344`
`332`	`345`	`PROCESS_SWITCH(LongrangecorrDerived, processTpcft0aSE, "same event TPC vs FT0A", false);`