diff --git a/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx
index 7a8c4cfb23e..f1753f94879 100644
--- a/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx
+++ b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx
@@ -56,6 +56,7 @@ using namespace o2::aod::fwdtrack;
 using namespace o2::constants::physics;
 using namespace o2::constants::math;
 using namespace pwgmm::mult;
+using namespace o2::aod::rctsel;
 
 auto static constexpr kMinCharge = 3.f;
 
@@ -63,7 +64,8 @@ AxisSpec ptAxis = {1001, -0.005, 10.005};
 AxisSpec multAxis = {701, -0.5, 700.5, "N_{trk}"};
 AxisSpec zAxis = {60, -30., 30.};
 AxisSpec deltaZAxis = {61, -6.1, 6.1};
-AxisSpec dcaxyAxis = {500, -1, 50};
+AxisSpec dcaxyAxis = {1000, 0., 5.};
+AxisSpec dcazAxis = {1000, 0., 5.};
 AxisSpec phiAxis = {629, 0, TwoPI, "Rad", "#phi"};
 AxisSpec etaAxis = {20, -4., -2.};
 AxisSpec centAxis{100, 0, 100, "centrality"};
@@ -101,6 +103,14 @@ struct DndetaMFTPbPb {
   Configurable<bool> cfgUseIRCut{"cfgUseIRCut", false, "Flag to cut on IR rate"};
   Configurable<bool> cfgIRCrashOnNull{"cfgIRCrashOnNull", false, "Flag to avoid CTP RateFetcher crash"};
   Configurable<std::string> cfgIRSource{"cfgIRSource", "T0VTX", "Estimator of the interaction rate (Pb-Pb: ZNC hadronic)"};
+  Configurable<bool> cfgUseTrackSel{"cfgUseTrackSel", false, "Flag to apply track selection"};
+
+  struct : ConfigurableGroup {
+    Configurable<bool> requireRCTFlagChecker{"requireRCTFlagChecker", false, "Check event quality in run condition table"};
+    Configurable<std::string> cfgEvtRCTFlagCheckerLabel{"cfgEvtRCTFlagCheckerLabel", "CBT_fw", "Evt sel: RCT flag checker label"};
+    Configurable<bool> cfgEvtRCTFlagCheckerZDCCheck{"cfgEvtRCTFlagCheckerZDCCheck", false, "Evt sel: RCT flag checker ZDC check"};
+    Configurable<bool> cfgEvtRCTFlagCheckerLimitAcceptAsBad{"cfgEvtRCTFlagCheckerLimitAcceptAsBad", true, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"};
+  } rctCuts;
 
   struct : ConfigurableGroup {
     Configurable<bool> usephiCut{"usephiCut", false, "use azimuthal angle cut"};
@@ -115,7 +125,8 @@ struct DndetaMFTPbPb {
     Configurable<bool> usePtCut{"usePtCut", false, "use track pT cut"};
     Configurable<double> minPt{"minPt", 0., "minimum pT of the MFT tracks"};
     Configurable<bool> requireCA{"requireCA", false, "Use Cellular Automaton track-finding algorithm"};
-    Configurable<float> maxDCAxy{"maxDCAxy", 2.0f, "Cut on dcaXY"};
+    Configurable<float> maxDCAxy{"maxDCAxy", 0.01f, "Cut on dca XY"};
+    Configurable<float> maxDCAz{"maxDCAz", 0.01f, "Cut on dca Z"};
   } trackCuts;
 
   struct : ConfigurableGroup {
@@ -141,6 +152,10 @@ struct DndetaMFTPbPb {
   ConfigurableAxis occupancyBins{"occupancyBins", {VARIABLE_WIDTH, 0.0f, 250.0f, 500.0f, 750.0f, 1000.0f, 1500.0f, 2000.0f, 3000.0f, 4500.0f, 6000.0f, 8000.0f, 10000.0f, 50000.0f}, "Occupancy"};
   ConfigurableAxis centralityBins{"centralityBins", {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, "Centrality"};
   ConfigurableAxis irBins{"irBins", {500, 0, 50}, "Interaction rate (kHz)"};
+  ConfigurableAxis pvBins{"pvBins", {501, -0.5, 500.5}, ""};
+  ConfigurableAxis fv0aMultBins{"fv0aMultBins", {501, -0.5, 500.5}, ""};
+  ConfigurableAxis ft0aMultBins{"ft0aMultBins", {501, -0.5, 500.5}, ""};
+  ConfigurableAxis ft0cMultBins{"ft0cMultBins", {501, -0.5, 500.5}, ""};
 
   Service<o2::framework::O2DatabasePDG> pdg;
 
@@ -154,10 +169,20 @@ struct DndetaMFTPbPb {
   std::unordered_map<int, TH2*> gHadronicRate;
   ctpRateFetcher rateFetcher;
   TH2* gCurrentHadronicRate;
+  RCTFlagsChecker rctChecker;
 
   /// @brief init function, definition of histograms
   void init(InitContext&)
   {
+    AxisSpec pvAxis = {pvBins, "PV", "PVAxis"};
+    AxisSpec multFV0aAxis = {fv0aMultBins, "fv0a", "FV0AMultAxis"};
+    AxisSpec multFT0aAxis = {ft0aMultBins, "ft0a", "FT0AMultAxis"};
+    AxisSpec multFT0cAxis = {ft0cMultBins, "ft0c", "FT0CMultAxis"};
+    AxisSpec centralityAxis = {centralityBins, "Centrality", "centralityAxis"};
+    AxisSpec occupancyAxis = {occupancyBins, "Occupancy", "occupancyAxis"};
+
+    rctChecker.init(rctCuts.cfgEvtRCTFlagCheckerLabel, rctCuts.cfgEvtRCTFlagCheckerZDCCheck, rctCuts.cfgEvtRCTFlagCheckerLimitAcceptAsBad);
+
     ccdb->setURL(ccdbUrl.value);
     ccdb->setCaching(true);
     ccdb->setLocalObjectValidityChecking();
@@ -220,7 +245,7 @@ struct DndetaMFTPbPb {
     }
 
     auto hev = registry.add<TH1>("Events/hEvtSel", "hEvtSel", HistType::kTH1F,
-                                 {{14, -0.5f, +13.5f}});
+                                 {{15, -0.5f, +14.5f}});
     hev->GetXaxis()->SetBinLabel(1, "All collisions");
     hev->GetXaxis()->SetBinLabel(2, "Ev. sel.");
     hev->GetXaxis()->SetBinLabel(3, "kIsGoodZvtxFT0vsPV");
@@ -234,6 +259,7 @@ struct DndetaMFTPbPb {
     hev->GetXaxis()->SetBinLabel(11, "kNoHighMultCollInPrevRof");
     hev->GetXaxis()->SetBinLabel(12, "Below min occup.");
     hev->GetXaxis()->SetBinLabel(13, "Above max occup.");
+    hev->GetXaxis()->SetBinLabel(14, "RCT Flag Checker");
 
     registry.add("Tracks/hTrkSel", "Number of tracks; Cut; #Tracks Passed Cut", {HistType::kTH1D, {{nTrkSel, 0, nTrkSel}}});
     registry.get<TH1>(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(trkSelNCls + 1, "Ncl cut");
@@ -249,9 +275,6 @@ struct DndetaMFTPbPb {
     hBcSel->GetXaxis()->SetBinLabel(2, "BCs with collisions");
     hBcSel->GetXaxis()->SetBinLabel(3, "BCs with pile-up/splitting");
 
-    AxisSpec centralityAxis = {centralityBins, "Centrality", "centralityAxis"};
-    AxisSpec occupancyAxis = {occupancyBins, "Occupancy", "occupancyAxis"};
-
     if (doprocessDataInclusive || doprocessDatawBestTracksInclusive ||
         doprocessMCInclusive || doprocessMCwBestTracksInclusive) {
       registry.add({"Events/Selection",
@@ -309,9 +332,16 @@ struct DndetaMFTPbPb {
           {"Tracks/DCAXYPt",
            "; p_{T} (GeV/c) ; DCA_{XY} (cm); occupancy",
            {HistType::kTHnSparseF, {ptAxis, dcaxyAxis, occupancyAxis}}});
+        qaregistry.add(
+          {"Tracks/DCAZPt",
+           "; p_{T} (GeV/c) ; DCA_{Z} (cm); occupancy",
+           {HistType::kTHnSparseF, {ptAxis, dcazAxis, occupancyAxis}}});
         qaregistry.add({"Tracks/DCAXY",
                         "; DCA_{XY} (cm); occupancy",
                         {HistType::kTH2F, {dcaxyAxis, occupancyAxis}}});
+        qaregistry.add({"Tracks/DCAZ",
+                        "; DCA_{Z} (cm); occupancy",
+                        {HistType::kTH2F, {dcazAxis, occupancyAxis}}});
         qaregistry.add(
           {"Tracks/ReTracksEtaZvtx",
            "; #eta; #it{z}_{vtx} (cm); occupancy",
@@ -414,11 +444,20 @@ struct DndetaMFTPbPb {
                         "; DCA_{XY} (cm); centrality; occupancy",
                         {HistType::kTHnSparseF,
                          {dcaxyAxis, centralityAxis, occupancyAxis}}});
+        qaregistry.add({"Tracks/Centrality/DCAZ",
+                        "; DCA_{Z} (cm); centrality; occupancy",
+                        {HistType::kTHnSparseF,
+                         {dcazAxis, centralityAxis, occupancyAxis}}});
         qaregistry.add(
           {"Tracks/Centrality/DCAXYPt",
            "; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality; occupancy",
            {HistType::kTHnSparseF,
             {ptAxis, dcaxyAxis, centralityAxis, occupancyAxis}}});
+        qaregistry.add(
+          {"Tracks/Centrality/DCAZPt",
+           "; p_{T} (GeV/c) ; DCA_{Z} (cm); centrality; occupancy",
+           {HistType::kTHnSparseF,
+            {ptAxis, dcazAxis, centralityAxis, occupancyAxis}}});
         qaregistry.add({"Tracks/Centrality/ReTracksEtaZvtx",
                         "; #eta; #it{z}_{vtx} (cm); occupancy",
                         {HistType::kTHnSparseF,
@@ -696,13 +735,22 @@ struct DndetaMFTPbPb {
                       {HistType::kTHnSparseF,
                        {ptAxis, phiAxis, etaAxis, zAxis, centralityAxis, occupancyAxis}}});
     }
+
+    if (doprocessCorrelationwBestTracksInclusive) {
+      qaregistry.add("Events/hMultMFTvsFT0A", "MultMFT_vs_FT0A", {HistType::kTH2F, {multAxis, multFT0aAxis}});
+      qaregistry.add("Events/hMultMFTvsFT0C", "MultMFT_vs_FT0C", {HistType::kTH2F, {multAxis, multFT0cAxis}});
+      qaregistry.add("Events/hNPVtracksVsFT0C", "NPVtracks_vs_FT0C", {HistType::kTH2F, {pvAxis, multFT0cAxis}});
+      qaregistry.add("Events/hMultMFTvsFV0A", "MultMFT_vs_FV0A", {HistType::kTH2F, {multAxis, multFV0aAxis}});
+      qaregistry.add("Events/hNPVtracksVsMultMFT", "NPVtracks_vs_MultMFT", {HistType::kTH2F, {pvAxis, multAxis}});
+    }
   }
 
   /// Filters - tracks
   Filter filtTrkEta = (aod::fwdtrack::eta < trackCuts.maxEta) &&
                       (aod::fwdtrack::eta > trackCuts.minEta);
   Filter filtATrackID = (aod::fwdtrack::bestCollisionId >= 0);
-  Filter filtATrackDCA = (nabs(aod::fwdtrack::bestDCAXY) < trackCuts.maxDCAxy);
+  Filter filtATrackDCAxy = (nabs(aod::fwdtrack::bestDCAXY) < trackCuts.maxDCAxy);
+  Filter filtATrackDCAz = (nabs(aod::fwdtrack::bestDCAZ) < trackCuts.maxDCAz);
 
   /// Filters - mc particles
   Filter primaries = (aod::mcparticle::flags &
@@ -728,10 +776,12 @@ struct DndetaMFTPbPb {
   using MFTTracksLabeled = soa::Join<aod::MFTTracks, aod::McMFTTrackLabels>;
   using MftTracksWColls = soa::Join<aod::MFTTracks, aod::MFTTrkCompColls>;
 
+  using CollsCorr = soa::Join<aod::Collisions, aod::EvSels, aod::Mults, aod::PVMults, aod::CentFT0Cs, aod::CentFV0As, aod::CentFT0CVariant1s, aod::CentFT0Ms, aod::CentNGlobals, aod::CentMFTs>;
+
   /// Filtered tables
   using FiltMftTracks = soa::Filtered<aod::MFTTracks>;
   using FiltMcMftTracks = soa::Filtered<MFTTracksLabeled>;
-  using FiltBestTracks = soa::Filtered<aod::BestCollisionsFwd>;
+  using FiltBestTracks = soa::Filtered<aod::BestCollisionsFwd3d>;
   using FiltParticles = soa::Filtered<aod::McParticles>;
 
   template <typename T>
@@ -855,8 +905,12 @@ struct DndetaMFTPbPb {
                           itrack.eta(), c, occ);
             qaregistry.fill(HIST("Tracks/Centrality/DCAXYPt"), itrack.pt(),
                             atrack.bestDCAXY(), c, occ);
+            qaregistry.fill(HIST("Tracks/Centrality/DCAZPt"), itrack.pt(),
+                            atrack.bestDCAZ(), c, occ);
             qaregistry.fill(HIST("Tracks/Centrality/DCAXY"), atrack.bestDCAXY(),
                             c, occ);
+            qaregistry.fill(HIST("Tracks/Centrality/DCAZ"), atrack.bestDCAZ(),
+                            c, occ);
             qaregistry.fill(HIST("Tracks/Centrality/NclustersEtaBest"),
                             itrack.nClusters(), itrack.eta(), c, occ);
             if (itrack.collisionId() != atrack.bestCollisionId()) {
@@ -872,7 +926,10 @@ struct DndetaMFTPbPb {
             registry.fill(HIST("Tracks/PhiEtaBest"), phi, itrack.eta(), occ);
             qaregistry.fill(HIST("Tracks/DCAXYPt"), itrack.pt(),
                             atrack.bestDCAXY(), occ);
+            qaregistry.fill(HIST("Tracks/DCAZPt"), itrack.pt(),
+                            atrack.bestDCAZ(), occ);
             qaregistry.fill(HIST("Tracks/DCAXY"), atrack.bestDCAXY(), occ);
+            qaregistry.fill(HIST("Tracks/DCAZ"), atrack.bestDCAZ(), occ);
             qaregistry.fill(HIST("Tracks/NclustersEtaBest"), itrack.nClusters(),
                             itrack.eta(), occ);
             if (itrack.collisionId() != atrack.bestCollisionId()) {
@@ -1021,6 +1078,13 @@ struct DndetaMFTPbPb {
     if constexpr (fillHis) {
       registry.fill(HIST("Events/hEvtSel"), 12);
     }
+
+    if (rctCuts.requireRCTFlagChecker && !rctChecker(collision)) {
+      return false;
+    }
+    if constexpr (fillHis) {
+      registry.fill(HIST("Events/hEvtSel"), 13);
+    }
     return true;
   }
 
@@ -1157,12 +1221,12 @@ struct DndetaMFTPbPb {
     }
   }
 
-  /// @brief process function for counting tracks (based on BestCollisionsFwd
+  /// @brief process function for counting tracks (based on BestCollisionsFwd3d
   /// table)
   template <typename C>
   void processDatawBestTracks(
     typename C::iterator const& collision, FiltMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks, CollBCs const& /*bcs*/)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks, CollBCs const& /*bcs*/)
   {
     auto occ = getOccupancy(collision, eventCuts.occupancyEstimator);
     float c = getRecoCent(collision);
@@ -1261,71 +1325,71 @@ struct DndetaMFTPbPb {
 
   void processDatawBestTracksInclusive(
     Colls::iterator const& collision, FiltMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks, CollBCs const& bcs)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks, CollBCs const& bcs)
   {
     processDatawBestTracks<Colls>(collision, tracks, besttracks, bcs);
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksInclusive,
-                 "Count tracks based on BestCollisionsFwd table (inclusive)",
+                 "Count tracks based on BestCollisionsFwd3d table (inclusive)",
                  false);
 
   void processDatawBestTracksCentFT0C(
     CollsCentFT0C::iterator const& collision, FiltMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks, CollBCs const& bcs)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks, CollBCs const& bcs)
   {
     processDatawBestTracks<CollsCentFT0C>(collision, tracks, besttracks, bcs);
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentFT0C,
-                 "Count tracks in FT0C centrality bins based on BestCollisionsFwd table",
+                 "Count tracks in FT0C centrality bins based on BestCollisionsFwd3d table",
                  false);
 
   void processDatawBestTracksCentFT0CVariant1(
     CollsCentFT0CVariant1::iterator const& collision,
     FiltMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks, CollBCs const& bcs)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks, CollBCs const& bcs)
   {
     processDatawBestTracks<CollsCentFT0CVariant1>(collision, tracks, besttracks, bcs);
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentFT0CVariant1,
                  "Count tracks in FT0CVariant1 centrality bins based on "
-                 "BestCollisionsFwd table",
+                 "BestCollisionsFwd3d table",
                  false);
 
   void processDatawBestTracksCentFT0M(
     CollsCentFT0M::iterator const& collision, FiltMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks, CollBCs const& bcs)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks, CollBCs const& bcs)
   {
     processDatawBestTracks<CollsCentFT0M>(collision, tracks, besttracks, bcs);
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentFT0M,
-                 "Count tracks in FT0M centrality bins based on BestCollisionsFwd table",
+                 "Count tracks in FT0M centrality bins based on BestCollisionsFwd3d table",
                  false);
 
   void processDatawBestTracksCentNGlobal(
     CollsCentNGlobal::iterator const& collision, FiltMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks, CollBCs const& bcs)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks, CollBCs const& bcs)
   {
     processDatawBestTracks<CollsCentNGlobal>(collision, tracks, besttracks, bcs);
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentNGlobal,
                  "Count tracks in NGlobal centrality bins based on "
-                 "BestCollisionsFwd table",
+                 "BestCollisionsFwd3d table",
                  false);
 
   void processDatawBestTracksCentMFT(
     CollsCentMFT::iterator const& collision, FiltMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks, CollBCs const& bcs)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks, CollBCs const& bcs)
   {
     processDatawBestTracks<CollsCentMFT>(collision, tracks, besttracks, bcs);
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentMFT,
-                 "Count tracks in MFT centrality bins based on BestCollisionsFwd table",
+                 "Count tracks in MFT centrality bins based on BestCollisionsFwd3d table",
                  false);
 
   Preslice<FiltMcMftTracks> perCol = o2::aod::fwdtrack::collisionId;
@@ -1533,11 +1597,11 @@ struct DndetaMFTPbPb {
   PROCESS_SWITCH(DndetaMFTPbPb, processMCCentMFT,
                  "Count MC particles in MFT centrality bins", false);
 
-  PresliceUnsorted<aod::BestCollisionsFwd> perColU =
+  PresliceUnsorted<aod::BestCollisionsFwd3d> perColU =
     aod::fwdtrack::bestCollisionId;
 
   /// @brief process template function to run on MC truth using
-  /// aod::BestCollisionsFwd tracks
+  /// aod::BestCollisionsFwd3d tracks
   template <typename MC, typename C>
   void processMCwBestTracks(
     typename MC::iterator const& mcCollision,
@@ -1646,7 +1710,7 @@ struct DndetaMFTPbPb {
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksInclusive,
-                 "Count MC particles using aod::BestCollisionsFwd (inclusive)",
+                 "Count MC particles using aod::BestCollisionsFwd3d (inclusive)",
                  false);
 
   void processMCwBestTracksCentFT0C(
@@ -1660,7 +1724,7 @@ struct DndetaMFTPbPb {
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentFT0C,
-                 "Count MC particles in FT0C centrality bins using aod::BestCollisionsFwd",
+                 "Count MC particles in FT0C centrality bins using aod::BestCollisionsFwd3d",
                  false);
 
   void processMCwBestTracksCentFT0CVariant1(
@@ -1676,7 +1740,7 @@ struct DndetaMFTPbPb {
 
   PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentFT0CVariant1,
                  "Count MC particles in FT0CVariant1 centrality bins using "
-                 "aod::BestCollisionsFwd",
+                 "aod::BestCollisionsFwd3d",
                  false);
 
   void processMCwBestTracksCentFT0M(
@@ -1690,7 +1754,7 @@ struct DndetaMFTPbPb {
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentFT0M,
-                 "Count MC particles in FT0M centrality bins using aod::BestCollisionsFwd",
+                 "Count MC particles in FT0M centrality bins using aod::BestCollisionsFwd3d",
                  false);
 
   void processMCwBestTracksCentNGlobal(
@@ -1706,7 +1770,7 @@ struct DndetaMFTPbPb {
 
   PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentNGlobal,
                  "Count MC particles in NGlobal centrality bins using "
-                 "aod::BestCollisionsFwd",
+                 "aod::BestCollisionsFwd3d",
                  false);
 
   void processMCwBestTracksCentMFT(
@@ -1720,7 +1784,7 @@ struct DndetaMFTPbPb {
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentMFT,
-                 "Count MC particles in MFT centrality bins using aod::BestCollisionsFwd",
+                 "Count MC particles in MFT centrality bins using aod::BestCollisionsFwd3d",
                  false);
 
   using ParticlesI = soa::Join<aod::McParticles, aod::ParticlesToMftTracks>;
@@ -1859,13 +1923,13 @@ struct DndetaMFTPbPb {
                  "Process tracking efficiency (in FT0C centrality bins, indexed)", false);
 
   /// @brief process function to calculate tracking efficiency (indexed) based
-  /// on BestCollisionsFwd in FT0C bins
+  /// on BestCollisionsFwd3d in FT0C bins
   template <typename C, typename MC>
   void processTrkEffBest(
     typename soa::Join<C, aod::McCollisionLabels>::iterator const& collision,
     MC const& /*mccollisions*/, FiltParticles const& particles,
     FiltMcMftTracks const& /*tracks*/,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks)
   {
     if (!isGoodEvent<false>(collision)) {
       return;
@@ -1927,21 +1991,21 @@ struct DndetaMFTPbPb {
     soa::Join<Colls, aod::McCollisionLabels>::iterator const& collision,
     aod::McCollisions const& mccollisions, FiltParticles const& particles,
     FiltMcMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks)
   {
     processTrkEffBest<Colls, aod::McCollisions>(collision, mccollisions,
                                                 particles, tracks, besttracks);
   }
 
   PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffBestInclusive,
-                 "Process tracking efficiency (inclusive, based on BestCollisionsFwd)",
+                 "Process tracking efficiency (inclusive, based on BestCollisionsFwd3d)",
                  false);
 
   void processTrkEffBestCentFT0C(
     soa::Join<CollsCentFT0C, aod::McCollisionLabels>::iterator const& collision,
     aod::McCollisions const& mccollisions, FiltParticles const& particles,
     FiltMcMftTracks const& tracks,
-    soa::SmallGroups<aod::BestCollisionsFwd> const& besttracks)
+    soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks)
   {
     processTrkEffBest<CollsCentFT0C, aod::McCollisions>(
       collision, mccollisions, particles, tracks, besttracks);
@@ -1949,7 +2013,7 @@ struct DndetaMFTPbPb {
 
   PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffBestCentFT0C,
                  "Process tracking efficiency (in FT0 centrality bins, based "
-                 "on BestCollisionsFwd)",
+                 "on BestCollisionsFwd3d)",
                  false);
 
   Preslice<FiltMcMftTracks> filtMcTrkperCol = o2::aod::fwdtrack::collisionId;
@@ -2182,6 +2246,38 @@ struct DndetaMFTPbPb {
 
   PROCESS_SWITCH(DndetaMFTPbPb, processMcQACentFT0C,
                  "Process MC QA checks (in FT0 centrality bins)", false);
+
+  template <typename C>
+  void processCorrelationwBestTracks(typename C::iterator const& collision, FiltMftTracks const& /*tracks*/, soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks)
+  {
+    if (!isGoodEvent<false>(collision)) {
+      return;
+    }
+
+    auto nBestTrks = 0;
+    for (auto const& atrack : besttracks) {
+      auto itrack = atrack.template mfttrack_as<FiltMftTracks>();
+      if (itrack.eta() < trackCuts.minEta || itrack.eta() > trackCuts.maxEta) {
+        continue;
+      }
+      if (cfgUseTrackSel && !isTrackSelected(itrack)) {
+        continue;
+      }
+      nBestTrks++;
+    }
+    qaregistry.fill(HIST("Events/hMultMFTvsFT0A"), nBestTrks, collision.multFT0A());
+    qaregistry.fill(HIST("Events/hMultMFTvsFT0C"), nBestTrks, collision.multFT0C());
+    qaregistry.fill(HIST("Events/hNPVtracksVsFT0C"), collision.multNTracksPV(), collision.multFT0C());
+    qaregistry.fill(HIST("Events/hMultMFTvsFV0A"), nBestTrks, collision.multFV0A());
+    qaregistry.fill(HIST("Events/hNPVtracksVsMultMFT"), collision.multNTracksPV(), nBestTrks);
+  }
+
+  void processCorrelationwBestTracksInclusive(CollsCorr::iterator const& collision, FiltMftTracks const& tracks, soa::SmallGroups<aod::BestCollisionsFwd3d> const& besttracks)
+  {
+    processCorrelationwBestTracks<CollsCorr>(collision, tracks, besttracks);
+  }
+
+  PROCESS_SWITCH(DndetaMFTPbPb, processCorrelationwBestTracksInclusive, "Do correlation study based on BestCollisionsFwd3d table", false);
 };
 
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)