From 74a5449cb51466449da3c170df32a5c184d47f2a Mon Sep 17 00:00:00 2001 From: zjxiongOvO Date: Mon, 11 May 2026 18:16:03 +0200 Subject: [PATCH] add efficiency weight method --- PWGDQ/Core/VarManager.cxx | 57 +++++++++++++++++++++++++++ PWGDQ/Core/VarManager.h | 14 +++++++ PWGDQ/Tasks/tableReader_withAssoc.cxx | 12 ++++++ 3 files changed, 83 insertions(+) diff --git a/PWGDQ/Core/VarManager.cxx b/PWGDQ/Core/VarManager.cxx index fa081babced..205c470f7da 100644 --- a/PWGDQ/Core/VarManager.cxx +++ b/PWGDQ/Core/VarManager.cxx @@ -74,6 +74,8 @@ std::map 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 bool VarManager::fgUseInterpolatedCalibration = true; // use interpolated calibration histograms (default: true) +int VarManager::fgEfficiencyType = 0; // type of efficiency to be applied, default is no efficiency +TObject* VarManager::fgEfficiencyHist = nullptr; // histogram for efficiency //__________________________________________________________________ VarManager::VarManager() : TObject() @@ -380,6 +382,58 @@ double VarManager::ComputePIDcalibration(int species, double nSigmaValue) } } +//__________________________________________________________________ +void VarManager::SetEfficiencyObject(int efficiencyType, TObject* obj) +{ + // check the type of the efficiency object and set it accordingly + if (efficiencyType >= kNEfficiencyTypes || efficiencyType < 0) { + LOG(warning) << "SetEfficiencyObject: unknown efficiency type " << efficiencyType; + return; + } + + // set the efficiency type + fgEfficiencyType = efficiencyType; + // set the efficiency object + fgEfficiencyHist = obj; +} + +void VarManager::FillEfficiency(float* values) +{ + // depending on the efficiency type, we use different types of efficiency histograms and different variables to get the efficiency value + if (!values) { + values = fgValues; + } + + if (fgEfficiencyType == kNone) { + values[kPairEfficiency] = 1.0; // if no efficiency is to be applied, set the efficiency value to 1 + values[kPairWeight] = 1.0; // set the weight to 1 + } else if (fgEfficiencyType == kPairPtCentFT0cCosThetaStarFT0c) { + if (!fgEfficiencyHist) { + LOG(fatal) << "efficiency histogram not set"; + return; + } + TH3F* efficiencyHist = reinterpret_cast(fgEfficiencyHist); + // Get the bin indices for the efficiency histogram + int binPt = efficiencyHist->GetXaxis()->FindBin(values[kPairPt]); + binPt = (binPt == 0 ? 1 : binPt); + binPt = (binPt > efficiencyHist->GetXaxis()->GetNbins() ? efficiencyHist->GetXaxis()->GetNbins() : binPt); + int binCent = efficiencyHist->GetYaxis()->FindBin(values[kCentFT0C]); + binCent = (binCent == 0 ? 1 : binCent); + binCent = (binCent > efficiencyHist->GetYaxis()->GetNbins() ? efficiencyHist->GetYaxis()->GetNbins() : binCent); + int binCosThetaStarFT0c = efficiencyHist->GetZaxis()->FindBin(values[kCosThetaStarFT0C]); + binCosThetaStarFT0c = (binCosThetaStarFT0c == 0 ? 1 : binCosThetaStarFT0c); + binCosThetaStarFT0c = (binCosThetaStarFT0c > efficiencyHist->GetZaxis()->GetNbins() ? efficiencyHist->GetZaxis()->GetNbins() : binCosThetaStarFT0c); + + // get the efficiency value from the histogram + values[kPairEfficiency] = efficiencyHist->GetBinContent(binPt, binCent, binCosThetaStarFT0c); + values[kPairWeight] = 1.0 / (values[kPairEfficiency] > 0 ? values[kPairEfficiency] : 1.0); // set the weight as the inverse of the efficiency, but avoid division by zero + } else { + LOG(warning) << "FillEfficiency: unknown efficiency type " << fgEfficiencyType << ", using default efficiency = 1"; + values[kPairEfficiency] = 1; + values[kPairWeight] = 1; + } +} + //__________________________________________________________________ std::tuple VarManager::BimodalityCoefficientUnbinned(const std::vector& data) { @@ -1535,6 +1589,8 @@ void VarManager::SetDefaultVarNames() fgVariableUnits[kCos2ThetaStarRandom] = ""; fgVariableNames[kMCCosThetaStar] = "cos#it{#theta}^{*}_{MC}"; fgVariableUnits[kMCCosThetaStar] = ""; + fgVariableNames[kPairWeight] = "weight"; + fgVariableUnits[kPairWeight] = ""; fgVariableNames[kCosPhiVP] = "cos#it{#varphi}_{VP}"; fgVariableUnits[kCosPhiVP] = ""; fgVariableNames[kPhiVP] = "#varphi_{VP} - #Psi_{2}"; @@ -2364,6 +2420,7 @@ void VarManager::SetDefaultVarNames() fgVarNamesMap["kCosThetaStarRandom"] = kCosThetaStarRandom; fgVarNamesMap["kCos2ThetaStarRandom"] = kCos2ThetaStarRandom; fgVarNamesMap["kMCCosThetaStar"] = kMCCosThetaStar; + fgVarNamesMap["kPairWeight"] = kPairWeight; fgVarNamesMap["kCosPhiVP"] = kCosPhiVP; fgVarNamesMap["kPhiVP"] = kPhiVP; fgVarNamesMap["kDeltaPhiPair2"] = kDeltaPhiPair2; diff --git a/PWGDQ/Core/VarManager.h b/PWGDQ/Core/VarManager.h index 37e0523cd91..cc803475d8c 100644 --- a/PWGDQ/Core/VarManager.h +++ b/PWGDQ/Core/VarManager.h @@ -928,6 +928,8 @@ class VarManager : public TObject kS12, kS13, kS23, + kPairEfficiency, + kPairWeight, kNPairVariables, // Candidate-track correlation variables @@ -1113,6 +1115,13 @@ class VarManager : public TObject kNCalibObjects }; + enum EfficiencyType { + kNone = 0, + kPairPtCentFT0cCosThetaStarFT0c, + // Add more efficiency types as needed + kNEfficiencyTypes + }; + enum DileptonCharmHadronTypes { kJPsi = 0, kD0ToPiK, @@ -1464,6 +1473,8 @@ class VarManager : public TObject } static double ComputePIDcalibration(int species, double nSigmaValue); + static void SetEfficiencyObject(int type, TObject* obj); + static void FillEfficiency(float* values = nullptr); static TObject* GetCalibrationObject(CalibObjects calib) { auto obj = fgCalibs.find(calib); @@ -1547,6 +1558,9 @@ class VarManager : public TObject 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 bool fgUseInterpolatedCalibration; // use interpolated calibration histograms (default: true) + static int fgEfficiencyType; // type of efficiency correction to apply + static TObject* fgEfficiencyHist; // histogram for efficiency correction + VarManager& operator=(const VarManager& c); VarManager(const VarManager& c); diff --git a/PWGDQ/Tasks/tableReader_withAssoc.cxx b/PWGDQ/Tasks/tableReader_withAssoc.cxx index d5bcfc56797..d0b5a93a559 100644 --- a/PWGDQ/Tasks/tableReader_withAssoc.cxx +++ b/PWGDQ/Tasks/tableReader_withAssoc.cxx @@ -1302,6 +1302,7 @@ struct AnalysisSameEventPairing { Configurable lutPath{"lutPath", "GLO/Param/MatLUT", "Path of the Lut parametrization"}; Configurable geoPath{"geoPath", "GLO/Config/GeometryAligned", "Path of the geometry file"}; Configurable GrpLhcIfPath{"grplhcif", "GLO/Config/GRPLHCIF", "Path on the CCDB for the GRPLHCIF object"}; + Configurable efficiencyPath{"effHistPath", "Users/z/zhxiong/efficiency", "Path on the CCDB for the efficiency histograms"}; } fConfigCCDB; struct : ConfigurableGroup { @@ -1318,6 +1319,8 @@ struct AnalysisSameEventPairing { Configurable centerMassEnergy{"energy", 13600, "Center of mass energy in GeV"}; Configurable propTrack{"cfgPropTrack", true, "Propgate tracks to associated collision to recalculate DCA and momentum vector"}; Configurable useRemoteCollisionInfo{"cfgUseRemoteCollisionInfo", false, "Use remote collision information from CCDB"}; + Configurable useEfficiencyWeighting{"cfgUseEfficiencyWeighting", false, "Apply efficiency weighting to the pairs from CCDB"}; + Configurable efficiencyType{"cfgEfficiencyType", 0, "Type of efficiency to apply from CCDB: 0 no efficiency, 1 pt-cent-costhetastar"}; } fConfigOptions; struct : ConfigurableGroup { Configurable applyBDT{"applyBDT", false, "Flag to apply ML selections"}; @@ -1731,6 +1734,11 @@ struct AnalysisSameEventPairing { o2::parameters::GRPLHCIFData* grpo = fCCDB->getForTimeStamp(fConfigCCDB.GrpLhcIfPath, timestamp); VarManager::SetCollisionSystem(grpo); } + + if (fConfigOptions.useEfficiencyWeighting) { + auto effList = fCCDB->getForTimeStamp(fConfigCCDB.efficiencyPath.value, timestamp); + VarManager::SetEfficiencyObject(fConfigOptions.efficiencyType.value, effList->FindObject("efficiency")); + } } // Template function to run same event pairing (barrel-barrel, muon-muon, barrel-muon) @@ -1853,6 +1861,10 @@ struct AnalysisSameEventPairing { VarManager::FillPairVn(t1, t2); } + if (fConfigOptions.useEfficiencyWeighting) { + VarManager::FillEfficiency(); + } + dielectronList(event.globalIndex(), VarManager::fgValues[VarManager::kMass], VarManager::fgValues[VarManager::kPt], VarManager::fgValues[VarManager::kEta], VarManager::fgValues[VarManager::kPhi], t1.sign() + t2.sign(), twoTrackFilter, 0);