Skip to content

[PWGLF] fixed the mixing logic which is now run time configurable for all cen… #18687

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
mpuccio merged 3 commits into from
Nov 12, 2026
Merged

[PWGLF] fixed the mixing logic which is now run time configurable for all cen… #18687

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
f647971
fixed the mixing logic which is now run time configurable for all cen…
bhattdurgesh921-sys Nov 11, 2026
eb41d2f
Added global tracks without DCA cuts selection and makes it configura…
bhattdurgesh921-sys Nov 11, 2026
23e85bc
added the spin alignment part for the code and also added various his…
bhattdurgesh921-sys Nov 11, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
98 changes: 48 additions & 50 deletions PWGLF/Tasks/Resonances/deltaAnalysis.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -48,6 +48,7 @@
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <utility>
Expand Down Expand Up @@ -127,7 +128,8 @@ struct DeltaAnalysis {
Configurable<bool> applyTPCChi2NClCut{"applyTPCChi2NClCut", true, "Enable/disable maximum TPC chi2/NCl cut"};
Configurable<bool> applyITSChi2NClCut{"applyITSChi2NClCut", true, "Enable/disable maximum ITS chi2/NCl cut"};
Configurable<bool> requirePrimaryTrack{"requirePrimaryTrack", true, "Require isPrimaryTrack flag"};
Configurable<bool> requireGlobalTrack{"requireGlobalTrack", true, "Require global track"};
Configurable<bool> requireGlobalTrack{"requireGlobalTrack", true, "Require global track (includes the DCA cuts of the standard global-track selection)"};
Configurable<bool> requireGlobalTrackWoDCA{"requireGlobalTrackWoDCA", false, "Require global track without DCA cuts (isGlobalTrackWoDCA). Mutually exclusive with requireGlobalTrack"};
Configurable<bool> requirePVContributor{"requirePVContributor", true, "Require PV-contributor flag"};
} trackCuts;

Expand Down Expand Up @@ -226,6 +228,11 @@ struct DeltaAnalysis {
<< ", bins=" << binsVec.size() << ")";
}
};
if (trackCuts.requireGlobalTrack && trackCuts.requireGlobalTrackWoDCA) {
LOG(fatal) << "requireGlobalTrack and requireGlobalTrackWoDCA are mutually exclusive: "
<< "enable only one of them (or neither).";
}

chkSz(protonPID.protonTPCNSigmaCutPerBin, protonPID.protonTPCPIDMomentumBins, "proton TPC PID");
chkSz(protonPID.protonTOFNSigmaCutPerBin, protonPID.protonTOFPIDMomentumBins, "proton TOF PID");
chkSz(pionPID.pionTPCNSigmaCutPerBin, pionPID.pionTPCPIDMomentumBins, "pion TPC PID");
Expand All @@ -246,15 +253,15 @@ struct DeltaAnalysis {
mPionDCAPtEdges = dcaCuts.pionDCAPtBinEdges.value;
mPionMaxDCAxy = dcaCuts.pionMaxDCAxyPerPtBin.value;

const AxisSpec ptAxis{50, 0., 20., "p_{T} (GeV/c)"};
const AxisSpec ptAxis{50, 0., 12., "p_{T} (GeV/c)"};
const AxisSpec massAxis{trackCuts.numberOfInvMassBins, 1.0, 6.0, "M_{inv} (GeV/#it{c}^{2})"};
const AxisSpec centAxis{axes.cfgCentAxis, "Centrality (%)"};
const AxisSpec vtxAxis{axes.cfgVtxAxis, "Vertex z [cm]"};
const AxisSpec rapAxis{axes.cfgRapAxis, "Rapidity y"};
const AxisSpec nSigmaTPCaxis{100, -5., 5., "n#sigma^{TPC}"};
const AxisSpec nSigmaTOFaxis{100, -5., 5., "n#sigma^{TOF}"};
const AxisSpec momentumAxis{50, 0., 20., "p (GeV/#it{c})"};
const AxisSpec ptForPIDAxis{50, 0., 20., "p_{T} (GeV/#it{c})"};
const AxisSpec momentumAxis{50, 0., 12., "p (GeV/#it{c})"};
const AxisSpec ptForPIDAxis{50, 0., 12., "p_{T} (GeV/#it{c})"};
const AxisSpec dcaXYaxis{200, -0.2f, 0.2f, "DCA_{xy} (cm)"};
const AxisSpec dcaZaxis{200, -1.2f, 1.2f, "DCA_{z} (cm)"};
const AxisSpec tpcClusAxis{200, 0, 200, "N_{clusters}^{TPC}"};
Expand Down Expand Up @@ -757,6 +764,9 @@ struct DeltaAnalysis {
if (trackCuts.requireGlobalTrack && !track.isGlobalTrack()) {
return false;
}
if (trackCuts.requireGlobalTrackWoDCA && !track.isGlobalTrackWoDCA()) {
return false;
}
if (trackCuts.requirePVContributor && !track.isPVContributor()) {
return false;
}
Expand Down Expand Up @@ -1429,18 +1439,6 @@ struct DeltaAnalysis {
using BinningTypeFV0A = ColumnBinningPolicy<aod::collision::PosZ, aod::cent::CentFV0A>;
using BinningTypeNTPV = ColumnBinningPolicy<aod::collision::PosZ, aod::cent::CentNTPV>;

BinningTypeFT0M binningFT0M{{axes.cfgVtxAxis, axes.cfgCentAxis}};
BinningTypeFT0A binningFT0A{{axes.cfgVtxAxis, axes.cfgCentAxis}};
BinningTypeFT0C binningFT0C{{axes.cfgVtxAxis, axes.cfgCentAxis}};
BinningTypeFV0A binningFV0A{{axes.cfgVtxAxis, axes.cfgCentAxis}};
BinningTypeNTPV binningNTPV{{axes.cfgVtxAxis, axes.cfgCentAxis}};

SameKindPair<EventCandidates, TrackCandidates, BinningTypeFT0M> pairFT0M{binningFT0M, mixingCfg.cfgNoMixedEvents, -1, &cache};
SameKindPair<EventCandidates, TrackCandidates, BinningTypeFT0A> pairFT0A{binningFT0A, mixingCfg.cfgNoMixedEvents, -1, &cache};
SameKindPair<EventCandidates, TrackCandidates, BinningTypeFT0C> pairFT0C{binningFT0C, mixingCfg.cfgNoMixedEvents, -1, &cache};
SameKindPair<EventCandidates, TrackCandidates, BinningTypeFV0A> pairFV0A{binningFV0A, mixingCfg.cfgNoMixedEvents, -1, &cache};
SameKindPair<EventCandidates, TrackCandidates, BinningTypeNTPV> pairNTPV{binningNTPV, mixingCfg.cfgNoMixedEvents, -1, &cache};

std::vector<TrackCandidate> mProtonPool;
std::vector<TrackCandidate> mPionPool;

Expand Down Expand Up @@ -1524,31 +1522,6 @@ struct DeltaAnalysis {
}
}

void processMixedEvent(EventCandidates const&, TrackCandidates const&)
{
switch (evSel.cfgCentralityEstimator) {
case delta_analysis::kFT0M:
runMixedEvent(pairFT0M);
break;
case delta_analysis::kFT0A:
runMixedEvent(pairFT0A);
break;
case delta_analysis::kFT0C:
runMixedEvent(pairFT0C);
break;
case delta_analysis::kFV0A:
runMixedEvent(pairFV0A);
break;
case delta_analysis::kNTPV:
runMixedEvent(pairNTPV);
break;
default:
runMixedEvent(pairFT0M);
break;
}
}
PROCESS_SWITCH(DeltaAnalysis, processMixedEvent, "Process mixed event", true);

// ── MC reconstructed event mixing ────────────────────────────────────────────────────────
// Mirrors runMixedEvent()/processMixedEvent() above exactly (same event-selection call, same
// "protons1+pions2" / "protons2+pions1" combinatorics, same centrality-estimator dispatch),
Expand All @@ -1574,32 +1547,57 @@ struct DeltaAnalysis {
}
}

void processMCEventMixing(EventCandidates const&, TrackCandidates const&)
template <typename BinningType>
void runMixingWithBinning(EventCandidates const& collisions, TrackCandidates const& tracks, bool isMC)
{
if (!mixingCfg.enableMCEventMixing) {
return;
BinningType binning{{axes.cfgVtxAxis, axes.cfgCentAxis}, true};
const int nMixedEvents = mixingCfg.cfgNoMixedEvents;
auto tracksTuple = std::make_tuple(tracks);
SameKindPair<EventCandidates, TrackCandidates, BinningType> mixingPair{binning, nMixedEvents, -1, collisions, tracksTuple, &cache};
if (isMC) {
runMixedEventMC(mixingPair);
} else {
runMixedEvent(mixingPair);
}
}

void dispatchMixing(EventCandidates const& collisions, TrackCandidates const& tracks, bool isMC)
{
switch (evSel.cfgCentralityEstimator) {
case delta_analysis::kFT0M:
runMixedEventMC(pairFT0M);
runMixingWithBinning<BinningTypeFT0M>(collisions, tracks, isMC);
break;
case delta_analysis::kFT0A:
runMixedEventMC(pairFT0A);
runMixingWithBinning<BinningTypeFT0A>(collisions, tracks, isMC);
break;
case delta_analysis::kFT0C:
runMixedEventMC(pairFT0C);
runMixingWithBinning<BinningTypeFT0C>(collisions, tracks, isMC);
break;
case delta_analysis::kFV0A:
runMixedEventMC(pairFV0A);
runMixingWithBinning<BinningTypeFV0A>(collisions, tracks, isMC);
break;
case delta_analysis::kNTPV:
runMixedEventMC(pairNTPV);
runMixingWithBinning<BinningTypeNTPV>(collisions, tracks, isMC);
break;
default:
runMixedEventMC(pairFT0M);
runMixingWithBinning<BinningTypeFT0M>(collisions, tracks, isMC);
break;
}
}

void processMixedEvent(EventCandidates const& collisions, TrackCandidates const& tracks)
{
dispatchMixing(collisions, tracks, false);
}
PROCESS_SWITCH(DeltaAnalysis, processMixedEvent, "Process mixed event", true);

void processMCEventMixing(EventCandidates const& collisions, TrackCandidates const& tracks)
{
if (!mixingCfg.enableMCEventMixing) {
return;
}
dispatchMixing(collisions, tracks, true);
}
PROCESS_SWITCH(DeltaAnalysis, processMCEventMixing, "Process MC reconstructed event mixing (reuses DATA mixing pairs; no truth matching)", false);

// =====================================================================================
Expand Down
Loading
Loading