CF correlations and JCorran multiplicity correlations histogram

Author: jaelpark

PWGCF/DataModel/CorrelationsDerived.h

@@ -90,7 +90,14 @@ DECLARE_SOA_TABLE(CFCollRefs, "AOD", "CFCOLLREF", o2::soa::Index<>, track::Colli
 namespace cfmultset
 {
 DECLARE_SOA_COLUMN(Multiplicities, multiplicities, std::vector<float>); //! List of auxiliary multiplicities
-}
+enum MultiplicityEstimators : uint8_t {
+  CentFT0C = 0x1,
+  MultFV0A = 0x2,
+  MultNTracksPV = 0x4,
+  MultNTracksGlobal = 0x8
+};
+
+} // namespace cfmultset
 DECLARE_SOA_TABLE(CFMultSets, "AOD", "CFMULTSET", cfmultset::Multiplicities); //! Auxilary multiplicity set table
 
 using CFMultSet = CFMultSets::iterator;

PWGCF/JCorran/Core/JFFlucAnalysis.cxx

@@ -12,10 +12,12 @@
 /// \author Jasper Parkkila (jparkkil@cern.ch)
 /// \since Sep 2022
 
-#include <TMath.h>
+#include "JFFlucAnalysis.h"
+
 #include <TComplex.h>
+#include <TMath.h>
+
 #include <algorithm>
-#include "JFFlucAnalysis.h"
 
 JFFlucAnalysis::JFFlucAnalysis() : TNamed(),
                                    fVertex(0),

PWGCF/JCorran/Core/JFFlucAnalysis.h

@@ -15,13 +15,16 @@
 #ifndef PWGCF_JCORRAN_CORE_JFFLUCANALYSIS_H_
 #define PWGCF_JCORRAN_CORE_JFFLUCANALYSIS_H_
 
-#include <experimental/type_traits>
 #include "JQVectors.h"
+
 #include <TComplex.h>
-#include <TNamed.h>
 #include <TH1.h>
 #include <THn.h>
 #include <THnSparse.h>
+#include <TNamed.h>
+
+#include <experimental/type_traits>
+#include <vector>
 
 class JFFlucAnalysis : public TNamed
 {
@@ -61,7 +64,6 @@ class JFFlucAnalysis : public TNamed
   enum HIST_THN {
     HIST_THN_PHIETAZ,
     HIST_THN_PTETA,
-    HIST_THN_PHIETA,
     HIST_THN_SC_with_QC_4corr,
     HIST_THN_SC_with_QC_2corr,
     HIST_THN_SC_with_QC_2corr_gap,
@@ -98,6 +100,7 @@ class JFFlucAnalysis : public TNamed
   enum HIST_THN_SPARSE {
     HIST_THN_SPARSE_VN,
     HIST_THN_SPARSE_VN_VN,
+    HIST_THN_SPARSE_MULTCORR,
     HIST_THN_SPARSE_COUNT
   };
   enum {
@@ -144,12 +147,17 @@ class JFFlucAnalysis : public TNamed
   using hasWeightEff = decltype(std::declval<T&>().weightEff());
   template <class T>
   using hasSign = decltype(std::declval<T&>().sign());
+  template <class T>
+  using hasMultSet = decltype(std::declval<T&>().multiplicities());
 
   template <class JInputClass>
   inline void FillQA(JInputClass& inputInst, UInt_t type = 0u)
   {
-    ph1[HIST_TH1_CENTRALITY]->Fill(fCent);
-    ph1[HIST_TH1_IMPACTPARAM]->Fill(fImpactParameter);
+    if (type == 0u) {
+      ph1[HIST_TH1_CENTRALITY]->Fill(fCent);
+      ph1[HIST_TH1_ZVERTEX]->Fill(fVertex);
+      ph1[HIST_TH1_IMPACTPARAM]->Fill(fImpactParameter);
+    }
 
     for (auto& track : inputInst) {
       Double_t corrInv = 1.0;
@@ -162,11 +170,19 @@ class JFFlucAnalysis : public TNamed
         pht[HIST_THN_PTETA]->Fill(fCent, track.pt(), track.eta(), 0.0, corrInv);
       if constexpr (std::experimental::is_detected<hasWeightNUA, const JInputClassIter>::value)
         corrInv /= track.weightNUA();
-      pht[HIST_THN_PHIETA]->Fill(fCent, track.phi(), track.eta(), corrInv);
       pht[HIST_THN_PHIETAZ]->Fill(fCent, static_cast<Double_t>(type), track.phi(), track.eta(), fVertex, corrInv);
     }
+  }
 
-    ph1[HIST_TH1_ZVERTEX]->Fill(fVertex);
+  template <class JEventClass>
+  inline void FillMultSet(JEventClass& event)
+  {
+    //
+    if constexpr (std::experimental::is_detected<hasMultSet, const JEventClass>::value) {
+      // need to convert to vec of doubles since THnSparse has no way to fill vec of floats directly
+      std::vector<double> v(event.multiplicities().begin(), event.multiplicities().end());
+      phs[HIST_THN_SPARSE_MULTCORR]->Fill(v.data());
+    }
   }
 
 #define kcNH kH4 // max second dimension + 1

PWGCF/JCorran/Core/JFFlucAnalysisO2Hist.cxx

@@ -12,24 +12,41 @@
 /// \since Sep 2024
 
 #include "JFFlucAnalysisO2Hist.h"
-#include <vector>
-#include <memory>
+
+#include "PWGCF/DataModel/CorrelationsDerived.h"
+
 #include "CommonConstants/MathConstants.h"
 
+#include <memory>
+#include <vector>
+
 using namespace o2;
 
-JFFlucAnalysisO2Hist::JFFlucAnalysisO2Hist(HistogramRegistry& registry, AxisSpec& axisMultiplicity, AxisSpec& phiAxis, AxisSpec& etaAxis, AxisSpec& zvtAxis, AxisSpec& ptAxis, AxisSpec& massAxis, const TString& folder) : JFFlucAnalysis()
+JFFlucAnalysisO2Hist::JFFlucAnalysisO2Hist(HistogramRegistry& registry, AxisSpec& axisMultiplicity, AxisSpec& phiAxis, AxisSpec& etaAxis, AxisSpec& zvtAxis, AxisSpec& ptAxis, AxisSpec& massAxis, uint16_t multCorrMask, const TString& folder) : JFFlucAnalysis()
 {
 
   ph1[HIST_TH1_CENTRALITY] = std::get<std::shared_ptr<TH1>>(registry.add(Form("%s/h_cent", folder.Data()), "multiplicity/centrality", {HistType::kTH1F, {axisMultiplicity}})).get();
   ph1[HIST_TH1_IMPACTPARAM] = std::get<std::shared_ptr<TH1>>(registry.add(Form("%s/h_IP", folder.Data()), "impact parameter", {HistType::kTH1F, {{400, -2.0, 20.0}}})).get();
   ph1[HIST_TH1_ZVERTEX] = std::get<std::shared_ptr<TH1>>(registry.add(Form("%s/h_vertex", folder.Data()), "z vertex", {HistType::kTH1F, {{100, -20.0, 20.0}}})).get();
 
+  if (multCorrMask != 0) {
+    std::vector<AxisSpec> multAxes;
+    if (multCorrMask & aod::cfmultset::CentFT0C)
+      multAxes.emplace_back(100, 0, 100, "FT0C centrality");
+    if (multCorrMask & aod::cfmultset::MultFV0A)
+      multAxes.emplace_back(100, 0, 100000, "V0A multiplicity");
+    if (multCorrMask & aod::cfmultset::MultNTracksPV)
+      multAxes.emplace_back(100, 0, 1000, "Nch PV");
+    if (multCorrMask & aod::cfmultset::MultNTracksGlobal)
+      multAxes.emplace_back(100, 0, 1000, "Nch Global");
+    registry.add("multCorrelations", "Multiplicity correlations", {HistType::kTHnSparseF, multAxes});
+    phs[HIST_THN_SPARSE_MULTCORR] = std::get<std::shared_ptr<THnSparse>>(registry.add(Form("%s/h_multcorr", folder.Data()), "multiplicity/centrality correlations", {HistType::kTHnSparseF, multAxes})).get();
+  }
+
   AxisSpec chgAxis = {3, -1.5, 1.5, "charge"};
   AxisSpec typeAxis = {2, -0.5, 1.5, "type"};
-  pht[HIST_THN_PHIETAZ] = std::get<std::shared_ptr<THnSparse>>(registry.add(Form("%s/h_phietaz", folder.Data()), "multiplicity/centrality, type, phi, eta, z", {HistType::kTHnSparseF, {axisMultiplicity, typeAxis, phiAxis, etaAxis, zvtAxis}})).get();
+  pht[HIST_THN_PHIETAZ] = std::get<std::shared_ptr<THnSparse>>(registry.add(Form("%s/h_phietaz", folder.Data()), "(corrected) multiplicity/centrality, type, phi, eta, z", {HistType::kTHnSparseF, {axisMultiplicity, typeAxis, phiAxis, etaAxis, zvtAxis}})).get();
   pht[HIST_THN_PTETA] = std::get<std::shared_ptr<THnSparse>>(registry.add(Form("%s/h_pteta", folder.Data()), "(corrected) multiplicity/centrality, pT, eta, charge", {HistType::kTHnSparseF, {axisMultiplicity, ptAxis, etaAxis, chgAxis}})).get();
-  pht[HIST_THN_PHIETA] = std::get<std::shared_ptr<THnSparse>>(registry.add(Form("%s/h_phieta", folder.Data()), "(corrected) multiplicity/centrality, phi, eta", {HistType::kTHnSparseF, {axisMultiplicity, phiAxis, etaAxis}})).get();
   AxisSpec hAxis = {kNH, -0.5, static_cast<double>(kNH - 1) + 0.5, "#it{n}"};
   AxisSpec kAxis = {nKL, -0.5, static_cast<double>(nKL - 1) + 0.5, "#it{k}"};
   AxisSpec vnAxis = {2048, -0.1, 0.1, "#it{V}_#it{n}"};

PWGCF/JCorran/Core/JFFlucAnalysisO2Hist.h

@@ -15,6 +15,7 @@
 #define PWGCF_JCORRAN_CORE_JFFLUCANALYSISO2HIST_H_
 
 #include "JFFlucAnalysis.h"
+
 #include "Framework/HistogramRegistry.h"
 
 using namespace o2;
@@ -23,7 +24,7 @@ using namespace o2::framework;
 class JFFlucAnalysisO2Hist : public JFFlucAnalysis
 {
  public:
-  JFFlucAnalysisO2Hist(HistogramRegistry&, AxisSpec&, AxisSpec&, AxisSpec&, AxisSpec&, AxisSpec&, AxisSpec&, const TString&);
+  JFFlucAnalysisO2Hist(HistogramRegistry&, AxisSpec&, AxisSpec&, AxisSpec&, AxisSpec&, AxisSpec&, AxisSpec&, uint16_t, const TString&);
   ~JFFlucAnalysisO2Hist();
 };
 

PWGCF/JCorran/Tasks/jflucAnalysisTask.cxx

@@ -55,6 +55,7 @@ struct jflucAnalysisTask {
   O2_DEFINE_CONFIGURABLE(ptmin, float, 0.2, "Minimum pt for tracks");
   O2_DEFINE_CONFIGURABLE(ptmax, float, 5.0, "Maximum pt for tracks");
   O2_DEFINE_CONFIGURABLE(cfgCentBinsForMC, int, 0, "0 = OFF and 1 = ON for data like multiplicity/centrality bins for MC process");
+  O2_DEFINE_CONFIGURABLE(cfgMultCorrelationsMask, uint16_t, 0, "Selection bitmask for the multiplicity correlations. This should match the filter selection cfgEstimatorBitMask.")
 
   ConfigurableAxis axisMultiplicity{"axisMultiplicity", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 100.1}, "multiplicity / centrality axis for histograms"};
   ConfigurableAxis phiAxis{"axisPhi", {50, 0.0, o2::constants::math::TwoPI}, "phi axis for histograms"};
@@ -78,15 +79,15 @@ struct jflucAnalysisTask {
     auto axisSpecZvt = AxisSpec(zvtAxis);
     auto axisSpecPt = AxisSpec(ptAxis);
     auto axisSpecMass = AxisSpec(massAxis);
-    if (doprocessJDerived || doprocessJDerivedCorrected || doprocessCFDerived || doprocessCFDerivedCorrected || doprocessMCCFDerived) {
-      pcf = new JFFlucAnalysisO2Hist(registry, axisSpecMult, axisSpecPhi, axisSpecEta, axisSpecZvt, axisSpecPt, axisSpecMass, "jfluc");
+    if (doprocessJDerived || doprocessJDerivedCorrected || doprocessCFDerived || doprocessCFDerivedCorrected || doprocessCFDerivedMultSet || doprocessCFDerivedMultSetCorrected || doprocessMCCFDerived) {
+      pcf = new JFFlucAnalysisO2Hist(registry, axisSpecMult, axisSpecPhi, axisSpecEta, axisSpecZvt, axisSpecPt, axisSpecMass, cfgMultCorrelationsMask, "jfluc");
       pcf->AddFlags(JFFlucAnalysis::kFlucEbEWeighting);
       pcf->UserCreateOutputObjects();
     } else {
       pcf = 0;
     }
     if (doprocessCF2ProngDerived || doprocessCF2ProngDerivedCorrected) {
-      pcf2Prong = new JFFlucAnalysisO2Hist(registry, axisSpecMult, axisSpecPhi, axisSpecEta, axisSpecZvt, axisSpecPt, axisSpecMass, "jfluc2prong");
+      pcf2Prong = new JFFlucAnalysisO2Hist(registry, axisSpecMult, axisSpecPhi, axisSpecEta, axisSpecZvt, axisSpecPt, axisSpecMass, cfgMultCorrelationsMask, "jfluc2prong");
       pcf2Prong->AddFlags(JFFlucAnalysis::kFlucEbEWeighting);
       pcf2Prong->UserCreateOutputObjects();
 
@@ -95,6 +96,8 @@ struct jflucAnalysisTask {
     } else {
       pcf2Prong = 0;
     }
+    if ((doprocessCFDerivedMultSet || doprocessCFDerivedMultSetCorrected) && cfgMultCorrelationsMask == 0)
+      LOGF(fatal, "cfgMultCorrelationsMask can not be 0 when MultSet process functions are in use.");
   }
 
   template <class T>
@@ -107,6 +110,7 @@ struct jflucAnalysisTask {
     pcf->SetEventCentrality(collision.multiplicity());
     pcf->SetEventVertex(collision.posZ());
     pcf->FillQA(tracks);
+    pcf->FillMultSet(collision);
     qvecs.Calculate(tracks, etamin, etamax);
     pcf->SetJQVectors(&qvecs);
     pcf->UserExec("");
@@ -158,6 +162,22 @@ struct jflucAnalysisTask {
   }
   PROCESS_SWITCH(jflucAnalysisTask, processCFDerivedCorrected, "Process CF derived data with corrections", true);
 
+  void processCFDerivedMultSet(soa::Join<aod::CFCollisions, aod::CFMultSets>::iterator const& collision, soa::Filtered<aod::CFTracks> const& tracks)
+  {
+    if (std::popcount(cfgMultCorrelationsMask.value) != static_cast<int>(collision.multiplicities().size()))
+      LOGF(fatal, "Multiplicity selections (cfgMultCorrelationsMask = 0x%x) do not match the size of the table column (%ld). The histogram filling relies on the preservation of order.", cfgMultCorrelationsMask.value, collision.multiplicities().size());
+    analyze(collision, tracks);
+  }
+  PROCESS_SWITCH(jflucAnalysisTask, processCFDerivedMultSet, "Process CF derived data with multiplicity sets", false);
+
+  void processCFDerivedMultSetCorrected(soa::Join<aod::CFCollisions, aod::CFMultSets>::iterator const& collision, soa::Filtered<soa::Join<aod::CFTracks, aod::JWeights>> const& tracks)
+  {
+    if (std::popcount(cfgMultCorrelationsMask.value) != static_cast<int>(collision.multiplicities().size()))
+      LOGF(fatal, "Multiplicity selections (cfgMultCorrelationsMask = 0x%x) do not match the size of the table column (%ld). The histogram filling relies on the preservation of order.", cfgMultCorrelationsMask.value, collision.multiplicities().size());
+    analyze(collision, tracks);
+  }
+  PROCESS_SWITCH(jflucAnalysisTask, processCFDerivedMultSetCorrected, "Process CF derived data with corrections and multiplicity sets", false);
+
   void processCF2ProngDerived(aod::CFCollision const& collision, soa::Filtered<aod::CFTracks> const& tracks, soa::Filtered<aod::CF2ProngTracks> const& p2tracks)
   {
     analyze(collision, p2tracks, tracks);

PWGCF/TableProducer/filterCorrelations.cxx

@@ -64,13 +64,6 @@ struct FilterCF {
     kPIDProton = BIT(1)
   };
 
-  enum MultiplicityEstimators : uint8_t {
-    kCentFT0C = BIT(0),
-    kMultFV0A = BIT(1),
-    kMultNTracksPV = BIT(2),
-    kMultNTracksGlobal = BIT(3),
-  };
-
   // Configuration
   O2_DEFINE_CONFIGURABLE(cfgCutVertex, float, 7.0f, "Accepted z-vertex range")
   O2_DEFINE_CONFIGURABLE(cfgCutPt, float, 0.5f, "Minimal pT for tracks")
@@ -271,13 +264,13 @@ struct FilterCF {
 
     if constexpr (std::experimental::is_detected<HasMultTables, C1>::value) {
       multiplicities.clear();
-      if (cfgEstimatorBitMask & kCentFT0C)
+      if (cfgEstimatorBitMask & aod::cfmultset::CentFT0C)
         multiplicities.push_back(collision.centFT0C());
-      if (cfgEstimatorBitMask & kMultFV0A)
+      if (cfgEstimatorBitMask & aod::cfmultset::MultFV0A)
         multiplicities.push_back(collision.multFV0A());
-      if (cfgEstimatorBitMask & kMultNTracksPV)
+      if (cfgEstimatorBitMask & aod::cfmultset::MultNTracksPV)
         multiplicities.push_back(collision.multNTracksPV());
-      if (cfgEstimatorBitMask & kMultNTracksGlobal)
+      if (cfgEstimatorBitMask & aod::cfmultset::MultNTracksGlobal)
         multiplicities.push_back(collision.multNTracksGlobal());
       outputMultSets(multiplicities);
     }

PWGCF/Tasks/correlations.cxx

@@ -85,6 +85,7 @@ struct CorrelationTask {
   O2_DEFINE_CONFIGURABLE(cfgLocalEfficiency, int, 0, "0 = OFF and 1 = ON for local efficiency");
   O2_DEFINE_CONFIGURABLE(cfgCentBinsForMC, int, 0, "0 = OFF and 1 = ON for data like multiplicity/centrality bins for MC steps");
   O2_DEFINE_CONFIGURABLE(cfgTrackBitMask, uint16_t, 0, "BitMask for track selection systematics; refer to the enum TrackSelectionCuts in filtering task");
+  O2_DEFINE_CONFIGURABLE(cfgMultCorrelationsMask, uint16_t, 0, "Selection bitmask for the multiplicity correlations. This should match the filter selection cfgEstimatorBitMask.")
   // Suggested values: Photon: 0.004; K0 and Lambda: 0.005
   Configurable<LabeledArray<float>> cfgPairCut{"cfgPairCut", {kCfgPairCutDefaults[0], 5, {"Photon", "K0", "Lambda", "Phi", "Rho"}}, "Pair cuts on various particles"};
 
@@ -175,6 +176,20 @@ struct CorrelationTask {
         registry.add("invMassTwoPartDPhi", "2D 2-prong invariant mass (GeV/c^2)", {HistType::kTHnSparseF, {axisSpecMass, axisSpecMass, axisPtTrigger, axisPtAssoc, axisDeltaPhi}});
       }
     }
+    if (doprocessSameDerivedMultSet) {
+	  if(cfgMultCorrelationsMask == 0)
+	    LOGF(fatal,"cfgMultCorrelationsMask can not be 0 when MultSet process functions are in use.");
+      std::vector<AxisSpec> multAxes;
+      if (cfgMultCorrelationsMask & aod::cfmultset::CentFT0C)
+        multAxes.emplace_back(100, 0, 100, "FT0C centrality");
+      if (cfgMultCorrelationsMask & aod::cfmultset::MultFV0A)
+        multAxes.emplace_back(100, 0, 100000, "V0A multiplicity");
+      if (cfgMultCorrelationsMask & aod::cfmultset::MultNTracksPV)
+        multAxes.emplace_back(100, 0, 1000, "Nch PV");
+      if (cfgMultCorrelationsMask & aod::cfmultset::MultNTracksGlobal)
+        multAxes.emplace_back(100, 0, 1000, "Nch Global");
+      registry.add("multCorrelations", "Multiplicity correlations", {HistType::kTHnSparseF, multAxes});
+    }
     registry.add("multiplicity", "event multiplicity", {HistType::kTH1F, {{1000, 0, 100, "/multiplicity/centrality"}}});
     registry.add("yvspt", "y vs pT", {HistType::kTH2F, {{100, -1, 1, "y"}, {100, 0, 20, "p_{T}"}}}); // y vs pT for all tracks (control histogram)
 
@@ -272,10 +287,20 @@ struct CorrelationTask {
     return !((track.decay() == 0 && track.mlProbD0()[0] > cfgPtCentDepMLbkgSel->at(idx)) || (track.decay() == 1 && track.mlProbD0bar()[0] > cfgPtCentDepMLbkgSel->at(idx)));
   }
 
+  template <class T>
+  using HasMultSet = decltype(std::declval<T&>().multiplicities());
+
   template <typename TCollision, typename TTracks>
-  void fillQA(const TCollision& /*collision*/, float multiplicity, const TTracks& tracks)
+  void fillQA(const TCollision& collision, float multiplicity, const TTracks& tracks)
   {
     registry.fill(HIST("multiplicity"), multiplicity);
+    if constexpr (std::experimental::is_detected<HasMultSet, TCollision>::value) {
+      if (std::popcount(cfgMultCorrelationsMask.value) != static_cast<int>(collision.multiplicities().size()))
+        LOGF(fatal, "Multiplicity selections (cfgMultCorrelationsMask = 0x%x) do not match the size of the table column (%ld). The histogram filling relies on the preservation of order.", cfgMultCorrelationsMask.value, collision.multiplicities().size());
+      // need to convert to vec of doubles since THnSparse has no way to fill vec of floats directly
+      std::vector<double> v(collision.multiplicities().begin(), collision.multiplicities().end());
+      registry.get<THnSparse>(HIST("multCorrelations")).get()->Fill(v.data());
+    }
     for (const auto& track1 : tracks) {
       registry.fill(HIST("yields"), multiplicity, track1.pt(), track1.eta());
       registry.fill(HIST("etaphi"), multiplicity, track1.eta(), track1.phi());
@@ -565,8 +590,10 @@ struct CorrelationTask {
           if (cfgDecayParticleMask != 0 && (cfgDecayParticleMask & (1u << static_cast<uint32_t>(track2.decay()))) == 0u) {
             continue; // skip particles that do not match the decay mask
           }
-          if (cfgV0RapidityMax > 0 && std::abs(getV0Rapidity(track1)) > cfgV0RapidityMax) {
-            continue; // V0s are not allowed to be outside the rapidity range
+          if (cfgV0RapidityMax > 0) {
+            auto [t, y] = getV0Rapidity(track1);
+            if (t && std::abs(y) > cfgV0RapidityMax)
+              continue; // V0s are not allowed to be outside the rapidity range
           }
         }
 
@@ -739,8 +766,8 @@ struct CorrelationTask {
   }
   PROCESS_SWITCH(CorrelationTask, processSameAOD, "Process same event on AOD", true);
 
-  template <class TTracks1, class TTracks2>
-  void processSameDerivedT(DerivedCollisions::iterator const& collision, TTracks1 const& tracks1, TTracks2 const& tracks2)
+  template <class CollType, class TTracks1, class TTracks2>
+  void processSameDerivedT(CollType const& collision, TTracks1 const& tracks1, TTracks2 const& tracks2)
   {
     BinningTypeDerived configurableBinningDerived{{axisVertex, axisMultiplicity}, true}; // true is for 'ignore overflows' (true by default). Underflows and overflows will have bin -1.
     if (cfgVerbosity > 0) {
@@ -777,6 +804,12 @@ struct CorrelationTask {
   }
   PROCESS_SWITCH(CorrelationTask, processSameDerived, "Process same event on derived data", false);
 
+  void processSameDerivedMultSet(soa::Filtered<soa::Join<aod::CFCollisions, aod::CFMultSets>>::iterator const& collision, soa::Filtered<aod::CFTracks> const& tracks)
+  {
+    processSameDerivedT(collision, tracks, tracks);
+  }
+  PROCESS_SWITCH(CorrelationTask, processSameDerivedMultSet, "Process same event on derived data with multiplicity sets", false);
+
   void processSame2ProngDerived(DerivedCollisions::iterator const& collision, soa::Filtered<aod::CFTracks> const& tracks, soa::Filtered<aod::CF2ProngTracks> const& p2tracks)
   {
     processSameDerivedT(collision, p2tracks, tracks);
@@ -1140,7 +1173,7 @@ struct CorrelationTask {
       }
     }
 
-    if (!(doprocessSameDerived || doprocessSame2ProngDerived || doprocessSame2ProngDerivedML || doprocessSame2Prong2Prong || doprocessSame2Prong2ProngML)) {
+    if (!(doprocessSameDerived || doprocessSameDerivedMultSet || doprocessSame2ProngDerived || doprocessSame2ProngDerivedML || doprocessSame2Prong2Prong || doprocessSame2Prong2ProngML)) {
       if constexpr (std::experimental::is_detected<HasDecay, typename Particles1::iterator>::value)
         fillQA(mcCollision, multiplicity, mcParticles1, mcParticles2);
       else