Tune MC TPC PID to data

JinjooSeo · JinjooSeo · commit 23a853b13a6c · 2026-05-07T12:55:54.000+02:00
diff --git a/PWGDQ/Core/VarManager.cxx b/PWGDQ/Core/VarManager.cxx
@@ -23,6 +23,7 @@
 
 #include <Math/Vector4D.h> // IWYU pragma: keep (do not replace with Math/Vector4Dfwd.h)
 #include <Math/Vector4Dfwd.h>
+#include <TH2.h>
 #include <TH3.h>
 #include <THn.h>
 #include <TObject.h>
@@ -72,7 +73,7 @@ o2::vertexing::FwdDCAFitterN<3> VarManager::fgFitterThreeProngFwd;
 o2::globaltracking::MatchGlobalFwd VarManager::mMatching;
 std::map<VarManager::CalibObjects, TObject*> VarManager::fgCalibs;
 bool VarManager::fgRunTPCPostCalibration[4] = {false, false, false, false};
-int VarManager::fgCalibrationType = 0;                // 0 - no calibration, 1 - calibration vs (TPCncls,pIN,eta) typically for pp, 2 - calibration vs (eta,nPV,nLong,tLong) typically for PbPb
+int VarManager::fgCalibrationType = 0;                // 0 - no calibration, 1 - data calibration vs (TPCncls,pIN,eta), 2 - data calibration vs (eta,nPV,nLong,tLong), 3 - MC tuning vs (pIN,eta), 4 - MC tuning vs (pIN,eta,CentFT0C)
 bool VarManager::fgUseInterpolatedCalibration = true; // use interpolated calibration histograms (default: true)
 
 //__________________________________________________________________
@@ -373,6 +374,119 @@ double VarManager::ComputePIDcalibration(int species, double nSigmaValue)
         return nSigmaValue; // unknown status, return the original nSigma value
         break;
     }
+  } else if (fgCalibrationType == 3) {
+    CalibObjects calibMeanSim, calibSigmaSim, calibMeanData, calibSigmaData;
+    switch (species) {
+      case 0:
+        calibMeanSim = kTPCElectronMean;
+        calibSigmaSim = kTPCElectronSigma;
+        calibMeanData = kTPCElectronMeanData;
+        calibSigmaData = kTPCElectronSigmaData;
+        break;
+      case 1:
+        calibMeanSim = kTPCPionMean;
+        calibSigmaSim = kTPCPionSigma;
+        calibMeanData = kTPCPionMeanData;
+        calibSigmaData = kTPCPionSigmaData;
+        break;
+      case 2:
+        calibMeanSim = kTPCKaonMean;
+        calibSigmaSim = kTPCKaonSigma;
+        calibMeanData = kTPCKaonMeanData;
+        calibSigmaData = kTPCKaonSigmaData;
+        break;
+      case 3:
+        calibMeanSim = kTPCProtonMean;
+        calibSigmaSim = kTPCProtonSigma;
+        calibMeanData = kTPCProtonMeanData;
+        calibSigmaData = kTPCProtonSigmaData;
+        break;
+      default:
+        LOG(fatal) << "Invalid species for PID calibration: " << species;
+        return -999.0;
+    }
+
+    TH2* calibMeanSimHist = reinterpret_cast<TH2*>(fgCalibs[calibMeanSim]);
+    TH2* calibSigmaSimHist = reinterpret_cast<TH2*>(fgCalibs[calibSigmaSim]);
+    TH2* calibMeanDataHist = reinterpret_cast<TH2*>(fgCalibs[calibMeanData]);
+    TH2* calibSigmaDataHist = reinterpret_cast<TH2*>(fgCalibs[calibSigmaData]);
+    if (!calibMeanSimHist || !calibSigmaSimHist || !calibMeanDataHist || !calibSigmaDataHist) {
+      LOG(fatal) << "MC tuning histograms not found for species: " << species;
+      return -999.0;
+    }
+
+    int binPin = calibMeanSimHist->GetXaxis()->FindBin(fgValues[kPin]);
+    binPin = (binPin == 0 ? 1 : binPin);
+    binPin = (binPin > calibMeanSimHist->GetXaxis()->GetNbins() ? calibMeanSimHist->GetXaxis()->GetNbins() : binPin);
+    int binEta = calibMeanSimHist->GetYaxis()->FindBin(fgValues[kEta]);
+    binEta = (binEta == 0 ? 1 : binEta);
+    binEta = (binEta > calibMeanSimHist->GetYaxis()->GetNbins() ? calibMeanSimHist->GetYaxis()->GetNbins() : binEta);
+
+    double meanSim = calibMeanSimHist->GetBinContent(binPin, binEta);
+    double sigmaSim = calibSigmaSimHist->GetBinContent(binPin, binEta);
+    double meanData = calibMeanDataHist->GetBinContent(binPin, binEta);
+    double sigmaData = calibSigmaDataHist->GetBinContent(binPin, binEta);
+    return (nSigmaValue - meanSim) * (sigmaSim / sigmaData) + meanData;
+  } else if (fgCalibrationType == 4) {
+    CalibObjects calibMeanSim, calibSigmaSim, calibMeanData, calibSigmaData;
+    switch (species) {
+      case 0:
+        calibMeanSim = kTPCElectronMean;
+        calibSigmaSim = kTPCElectronSigma;
+        calibMeanData = kTPCElectronMeanData;
+        calibSigmaData = kTPCElectronSigmaData;
+        break;
+      case 1:
+        calibMeanSim = kTPCPionMean;
+        calibSigmaSim = kTPCPionSigma;
+        calibMeanData = kTPCPionMeanData;
+        calibSigmaData = kTPCPionSigmaData;
+        break;
+      case 2:
+        calibMeanSim = kTPCKaonMean;
+        calibSigmaSim = kTPCKaonSigma;
+        calibMeanData = kTPCKaonMeanData;
+        calibSigmaData = kTPCKaonSigmaData;
+        break;
+      case 3:
+        calibMeanSim = kTPCProtonMean;
+        calibSigmaSim = kTPCProtonSigma;
+        calibMeanData = kTPCProtonMeanData;
+        calibSigmaData = kTPCProtonSigmaData;
+        break;
+      default:
+        LOG(fatal) << "Invalid species for PID calibration: " << species;
+        return -999.0;
+    }
+
+    TH3F* calibMeanSimHist = reinterpret_cast<TH3F*>(fgCalibs[calibMeanSim]);
+    TH3F* calibSigmaSimHist = reinterpret_cast<TH3F*>(fgCalibs[calibSigmaSim]);
+    TH3F* calibMeanDataHist = reinterpret_cast<TH3F*>(fgCalibs[calibMeanData]);
+    TH3F* calibSigmaDataHist = reinterpret_cast<TH3F*>(fgCalibs[calibSigmaData]);
+    if (!calibMeanSimHist || !calibSigmaSimHist || !calibMeanDataHist || !calibSigmaDataHist) {
+      LOG(fatal) << "MC tuning histograms not found for species: " << species;
+      return -999.0;
+    }
+    if (fgValues[kCentFT0C] < -999.) {
+      LOG(fatal) << "TPC MC tuning calibration type 4 requires event centrality in VarManager::fgValues[kCentFT0C].";
+      return -999.0;
+    }
+
+    int binPin = calibMeanSimHist->GetXaxis()->FindBin(fgValues[kPin]);
+    binPin = (binPin == 0 ? 1 : binPin);
+    binPin = (binPin > calibMeanSimHist->GetXaxis()->GetNbins() ? calibMeanSimHist->GetXaxis()->GetNbins() : binPin);
+    int binEta = calibMeanSimHist->GetYaxis()->FindBin(fgValues[kEta]);
+    binEta = (binEta == 0 ? 1 : binEta);
+    binEta = (binEta > calibMeanSimHist->GetYaxis()->GetNbins() ? calibMeanSimHist->GetYaxis()->GetNbins() : binEta);
+    int binCent = calibMeanSimHist->GetZaxis()->FindBin(fgValues[kCentFT0C]);
+    binCent = (binCent == 0 ? 1 : binCent);
+    binCent = (binCent > calibMeanSimHist->GetZaxis()->GetNbins() ? calibMeanSimHist->GetZaxis()->GetNbins() : binCent);
+
+    double meanSim = calibMeanSimHist->GetBinContent(binPin, binEta, binCent);
+    double sigmaSim = calibSigmaSimHist->GetBinContent(binPin, binEta, binCent);
+    double meanData = calibMeanDataHist->GetBinContent(binPin, binEta, binCent);
+    double sigmaData = calibSigmaDataHist->GetBinContent(binPin, binEta, binCent);
+    return (nSigmaValue - meanSim) * (sigmaSim / sigmaData) + meanData;
   } else {
     // unknown calibration type, return the original nSigma value
     LOG(fatal) << "Unknown calibration type: " << fgCalibrationType;
diff --git a/PWGDQ/Core/VarManager.h b/PWGDQ/Core/VarManager.h
@@ -1101,15 +1101,23 @@ class VarManager : public TObject
     kTPCElectronMean = 0,
     kTPCElectronSigma,
     kTPCElectronStatus,
+    kTPCElectronMeanData,
+    kTPCElectronSigmaData,
     kTPCPionMean,
     kTPCPionSigma,
     kTPCPionStatus,
+    kTPCPionMeanData,
+    kTPCPionSigmaData,
     kTPCKaonMean,
     kTPCKaonSigma,
     kTPCKaonStatus,
+    kTPCKaonMeanData,
+    kTPCKaonSigmaData,
     kTPCProtonMean,
     kTPCProtonSigma,
     kTPCProtonStatus,
+    kTPCProtonMeanData,
+    kTPCProtonSigmaData,
     kNCalibObjects
   };
 
@@ -1456,8 +1464,8 @@ class VarManager : public TObject
 
   static void SetCalibrationType(int type, bool useInterpolation = true)
   {
-    if (type < 0 || type > 2) {
-      LOG(fatal) << "Invalid calibration type. Must be 0, 1, or 2.";
+    if (type < 0 || type > 4) {
+      LOG(fatal) << "Invalid calibration type. Must be between 0 and 4.";
     }
     fgCalibrationType = type;
     fgUseInterpolatedCalibration = useInterpolation;
@@ -1544,7 +1552,7 @@ class VarManager : public TObject
 
   static std::map<CalibObjects, TObject*> fgCalibs; // map of calibration histograms
   static bool fgRunTPCPostCalibration[4];           // 0-electron, 1-pion, 2-kaon, 3-proton
-  static int fgCalibrationType;                     // 0 - no calibration, 1 - calibration vs (TPCncls,pIN,eta) typically for pp, 2 - calibration vs (eta,nPV,nLong,tLong) typically for PbPb
+  static int fgCalibrationType;                     // 0 - no calibration, 1 - data calibration vs (TPCncls,pIN,eta), 2 - data calibration vs (eta,nPV,nLong,tLong), 3 - MC tuning vs (pIN,eta), 4 - MC tuning vs (pIN,eta,CentFT0C)
   static bool fgUseInterpolatedCalibration;         // use interpolated calibration histograms (default: true)
 
   VarManager& operator=(const VarManager& c);
diff --git a/PWGDQ/Tasks/dqEfficiency.cxx b/PWGDQ/Tasks/dqEfficiency.cxx
@@ -35,11 +35,13 @@
 #include <Framework/runDataProcessing.h>
 
 #include <THashList.h>
+#include <TList.h>
 #include <TMath.h>
 #include <TString.h>
 
 #include <RtypesCore.h>
 
+#include <chrono>
 #include <cstdint>
 #include <cstdio>
 #include <memory>
@@ -173,12 +175,60 @@ struct AnalysisTrackSelection {
   Configurable<std::string> fConfigCuts{"cfgTrackCuts", "jpsiPID1", "Comma separated list of barrel track cuts"};
   Configurable<std::string> fConfigMCSignals{"cfgTrackMCSignals", "", "Comma separated list of MC signals"};
   Configurable<bool> fConfigQA{"cfgQA", false, "If true, fill QA histograms"};
+  Configurable<std::string> fConfigCcdbUrl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"};
+  Configurable<std::string> fConfigCcdbPathTPC{"ccdb-path-tpc", "Users/z/zhxiong/TPCPID/PostCalib", "base path to the ccdb object"};
+  Configurable<int64_t> fConfigNoLaterThan{"ccdb-no-later-than", std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count(), "latest acceptable timestamp of creation for the object"};
+  Configurable<bool> fConfigComputeTPCpostCalib{"cfgTPCpostCalib", false, "If true, apply TPC PID correction maps for MC-to-data tuning"};
+  Configurable<int> fConfigTPCpostCalibType{"cfgTPCpostCalibType", 1, "1: (pIN,eta) calibration typically for pp, 2: (pIN,eta,CentFT0C) calibration typically for PbPb"};
 
+  Service<o2::ccdb::BasicCCDBManager> fCCDB;
   HistogramManager* fHistMan;
   std::vector<AnalysisCompositeCut> fTrackCuts;
   std::vector<MCSignal> fMCSignals; // list of signals to be checked
   std::vector<TString> fHistNamesReco;
   std::vector<std::vector<TString>> fHistNamesMCMatched;
+  int fCurrentRun = 0;
+
+  int getMCTuningCalibrationType() const
+  {
+    switch (fConfigTPCpostCalibType.value) {
+      case 1:
+        return 3;
+      case 2:
+        return 4;
+      default:
+        LOGF(fatal, "Invalid cfgTPCpostCalibType=%d for dqEfficiency. Supported values are 1:(pIN,eta) and 2:(pIN,eta,CentFT0C).", fConfigTPCpostCalibType.value);
+        return 3;
+    }
+  }
+
+  void setTPCPostCalibObject(TList* calibList, VarManager::CalibObjects calib, const char* objectName)
+  {
+    if (!calibList) {
+      LOGF(fatal, "TPC post-calibration list not found at CCDB path %s.", fConfigCcdbPathTPC.value.c_str());
+    }
+    auto* obj = calibList->FindObject(objectName);
+    if (!obj) {
+      LOGF(fatal, "TPC post-calibration object '%s' not found at CCDB path %s.", objectName, fConfigCcdbPathTPC.value.c_str());
+    }
+    VarManager::SetCalibrationObject(calib, obj);
+  }
+
+  void loadTPCPostCalibObjects(TList* calibList)
+  {
+    setTPCPostCalibObject(calibList, VarManager::kTPCElectronMean, "mean_map_electron");
+    setTPCPostCalibObject(calibList, VarManager::kTPCElectronSigma, "sigma_map_electron");
+    setTPCPostCalibObject(calibList, VarManager::kTPCElectronMeanData, "mean_map_electron_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCElectronSigmaData, "sigma_map_electron_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCPionMean, "mean_map_pion");
+    setTPCPostCalibObject(calibList, VarManager::kTPCPionSigma, "sigma_map_pion");
+    setTPCPostCalibObject(calibList, VarManager::kTPCPionMeanData, "mean_map_pion_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCPionSigmaData, "sigma_map_pion_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCProtonMean, "mean_map_proton");
+    setTPCPostCalibObject(calibList, VarManager::kTPCProtonSigma, "sigma_map_proton");
+    setTPCPostCalibObject(calibList, VarManager::kTPCProtonMeanData, "mean_map_proton_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCProtonSigmaData, "sigma_map_proton_data");
+  }
 
   void init(o2::framework::InitContext& context)
   {
@@ -236,11 +286,25 @@ struct AnalysisTrackSelection {
       VarManager::SetUseVars(fHistMan->GetUsedVars()); // provide the list of required variables so that VarManager knows what to fill
       fOutputList.setObject(fHistMan->GetMainHistogramList());
     }
+
+    if (fConfigComputeTPCpostCalib) {
+      fCCDB->setURL(fConfigCcdbUrl.value);
+      fCCDB->setCaching(true);
+      fCCDB->setLocalObjectValidityChecking();
+      fCCDB->setCreatedNotAfter(fConfigNoLaterThan.value);
+    }
   }
 
   template <uint32_t TEventFillMap, uint32_t TEventMCFillMap, uint32_t TTrackFillMap, uint32_t TTrackMCFillMap, typename TEvent, typename TTracks, typename TEventsMC, typename TTracksMC>
   void runSelection(TEvent const& event, TTracks const& tracks, TEventsMC const& /*eventsMC*/, TTracksMC const& /*tracksMC*/)
   {
+    if (fConfigComputeTPCpostCalib && fCurrentRun != event.runNumber()) {
+      auto calibList = fCCDB->getForTimeStamp<TList>(fConfigCcdbPathTPC.value, event.timestamp());
+      loadTPCPostCalibObjects(calibList);
+      VarManager::SetCalibrationType(getMCTuningCalibrationType());
+      fCurrentRun = event.runNumber();
+    }
+
     VarManager::ResetValues(0, VarManager::kNMCParticleVariables);
     // fill event information which might be needed in histograms that combine track and event properties
     VarManager::FillEvent<TEventFillMap>(event);
diff --git a/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx b/PWGDQ/Tasks/dqEfficiency_withAssoc.cxx
@@ -536,7 +536,8 @@ struct AnalysisTrackSelection {
   Configurable<std::string> fConfigCcdbUrl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"};
   Configurable<std::string> fConfigCcdbPathTPC{"ccdb-path-tpc", "Users/z/zhxiong/TPCPID/PostCalib", "base path to the ccdb object"};
   Configurable<int64_t> fConfigNoLaterThan{"ccdb-no-later-than", std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count(), "latest acceptable timestamp of creation for the object"};
-  Configurable<bool> fConfigComputeTPCpostCalib{"cfgTPCpostCalib", false, "If true, compute TPC post-calibrated n-sigmas"};
+  Configurable<bool> fConfigComputeTPCpostCalib{"cfgTPCpostCalib", false, "If true, apply TPC PID correction maps for MC-to-data tuning"};
+  Configurable<int> fConfigTPCpostCalibType{"cfgTPCpostCalibType", 1, "1: (pIN,eta) calibration typically for pp, 2: (pIN,eta,CentFT0C) calibration typically for PbPb"};
   Configurable<std::string> grpmagPath{"grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"};
 
   Configurable<std::string> fConfigMCSignals{"cfgTrackMCSignals", "", "Comma separated list of MC signals"};
@@ -555,6 +556,47 @@ struct AnalysisTrackSelection {
   std::map<int64_t, std::vector<int64_t>> fNAssocsInBunch;    // key: track global index, value: vector of global index for events associated in-bunch (events that have in-bunch pileup or splitting)
   std::map<int64_t, std::vector<int64_t>> fNAssocsOutOfBunch; // key: track global index, value: vector of global index for events associated out-of-bunch (events that have no in-bunch pileup)
 
+  int getMCTuningCalibrationType() const
+  {
+    switch (fConfigTPCpostCalibType.value) {
+      case 1:
+        return 3;
+      case 2:
+        return 4;
+      default:
+        LOGF(fatal, "Invalid cfgTPCpostCalibType=%d for dqEfficiency_withAssoc. Supported values are 1:(pIN,eta) and 2:(pIN,eta,CentFT0C).", fConfigTPCpostCalibType.value);
+        return 3;
+    }
+  }
+
+  void setTPCPostCalibObject(TList* calibList, VarManager::CalibObjects calib, const char* objectName)
+  {
+    if (!calibList) {
+      LOGF(fatal, "TPC post-calibration list not found at CCDB path %s.", fConfigCcdbPathTPC.value.c_str());
+    }
+    auto* obj = calibList->FindObject(objectName);
+    if (!obj) {
+      LOGF(fatal, "TPC post-calibration object '%s' not found at CCDB path %s.", objectName, fConfigCcdbPathTPC.value.c_str());
+    }
+    VarManager::SetCalibrationObject(calib, obj);
+  }
+
+  void loadTPCPostCalibObjects(TList* calibList)
+  {
+    setTPCPostCalibObject(calibList, VarManager::kTPCElectronMean, "mean_map_electron");
+    setTPCPostCalibObject(calibList, VarManager::kTPCElectronSigma, "sigma_map_electron");
+    setTPCPostCalibObject(calibList, VarManager::kTPCElectronMeanData, "mean_map_electron_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCElectronSigmaData, "sigma_map_electron_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCPionMean, "mean_map_pion");
+    setTPCPostCalibObject(calibList, VarManager::kTPCPionSigma, "sigma_map_pion");
+    setTPCPostCalibObject(calibList, VarManager::kTPCPionMeanData, "mean_map_pion_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCPionSigmaData, "sigma_map_pion_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCProtonMean, "mean_map_proton");
+    setTPCPostCalibObject(calibList, VarManager::kTPCProtonSigma, "sigma_map_proton");
+    setTPCPostCalibObject(calibList, VarManager::kTPCProtonMeanData, "mean_map_proton_data");
+    setTPCPostCalibObject(calibList, VarManager::kTPCProtonSigmaData, "sigma_map_proton_data");
+  }
+
   void init(o2::framework::InitContext& context)
   {
     if (context.mOptions.get<bool>("processDummy")) {
@@ -649,16 +691,11 @@ struct AnalysisTrackSelection {
     fNAssocsInBunch.clear();
     fNAssocsOutOfBunch.clear();
 
-    // TODO: Check if postcalibration needed for MC
     if (events.size() > 0 && fCurrentRun != events.begin().runNumber()) {
       if (fConfigComputeTPCpostCalib) {
         auto calibList = fCCDB->getForTimeStamp<TList>(fConfigCcdbPathTPC.value, events.begin().timestamp());
-        VarManager::SetCalibrationObject(VarManager::kTPCElectronMean, calibList->FindObject("mean_map_electron"));
-        VarManager::SetCalibrationObject(VarManager::kTPCElectronSigma, calibList->FindObject("sigma_map_electron"));
-        VarManager::SetCalibrationObject(VarManager::kTPCPionMean, calibList->FindObject("mean_map_pion"));
-        VarManager::SetCalibrationObject(VarManager::kTPCPionSigma, calibList->FindObject("sigma_map_pion"));
-        VarManager::SetCalibrationObject(VarManager::kTPCProtonMean, calibList->FindObject("mean_map_proton"));
-        VarManager::SetCalibrationObject(VarManager::kTPCProtonSigma, calibList->FindObject("sigma_map_proton"));
+        loadTPCPostCalibObjects(calibList);
+        VarManager::SetCalibrationType(getMCTuningCalibrationType());
       }
 
       o2::parameters::GRPMagField* grpmag = fCCDB->getForTimeStamp<o2::parameters::GRPMagField>(grpmagPath, events.begin().timestamp());
@@ -2236,6 +2273,10 @@ struct AnalysisSameEventPairing {
         continue;
       }
 
+      VarManager::ResetValues(0, VarManager::kNVars);
+      VarManager::FillEvent<gkEventFillMap>(event, VarManager::fgValues);
+      VarManager::FillEvent<VarManager::ObjTypes::ReducedEventMC>(event.reducedMCevent(), VarManager::fgValues);
+
       FinalStateMcParticleIndices.clear();
 
       auto groupedMCTracks = mcTracks.sliceBy(perReducedMcEvent, event.reducedMCeventId());
@@ -2398,6 +2439,7 @@ struct AnalysisSameEventPairing {
       if (!event.has_reducedMCevent()) {
         continue;
       }
+      VarManager::ResetValues(0, VarManager::kNVars);
       VarManager::FillEvent<gkEventFillMap>(event, VarManager::fgValues);
       VarManager::FillEvent<VarManager::ObjTypes::ReducedEventMC>(event.reducedMCevent(), VarManager::fgValues);
       // auto groupedMCTracks = mcTracks.sliceBy(perReducedMcGenEvent, event.reducedMCeventId());
@@ -2511,6 +2553,9 @@ struct AnalysisSameEventPairing {
       if (!event.has_reducedMCevent()) {
         continue;
       }
+      VarManager::ResetValues(0, VarManager::kNVars);
+      VarManager::FillEvent<gkEventFillMap>(event, VarManager::fgValues);
+      VarManager::FillEvent<VarManager::ObjTypes::ReducedEventMC>(event.reducedMCevent(), VarManager::fgValues);
 
       for (auto& track : mcTracks) {
         if (track.reducedMCeventId() != event.reducedMCeventId()) {
diff --git a/PWGDQ/Tasks/dqEfficiency_withAssoc_direct.cxx b/PWGDQ/Tasks/dqEfficiency_withAssoc_direct.cxx
