Skip to content

Please consider the following formatting changes to #15567 #33

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
Simple-Shyam merged 1 commit into from
Mar 29, 2026
+136 −138
Merged

Please consider the following formatting changes to #15567 #33

Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
274 changes: 136 additions & 138 deletions PWGHF/HFC/TableProducer/correlatorDplusHadrons.cxx
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -186,7 +186,7 @@ struct HfCorrelatorDplusHadrons {

Configurable<int> selectionFlagDplus{"selectionFlagDplus", 7, "Selection Flag for Dplus"}; // 7 corresponds to topo+PID cuts
Configurable<int> numberEventsMixed{"numberEventsMixed", 5, "Number of events mixed in ME process"};
Configurable<bool> removeUnreconstructedGenCollisions{"removeUnreconstructedGenCollisions",true,"Remove generator-level collisions that were not reconstructed"};
Configurable<bool> removeUnreconstructedGenCollisions{"removeUnreconstructedGenCollisions", true, "Remove generator-level collisions that were not reconstructed"};
Configurable<bool> removeCollWSplitVtx{"removeCollWSplitVtx", true, "Flag for rejecting the splitted collisions"};
Configurable<bool> useSel8{"useSel8", true, "Flag for applying sel8 for collision selection"};
Configurable<bool> selNoSameBunchPileUpColl{"selNoSameBunchPileUpColl", true, "Flag for rejecting the collisions associated with the same bunch crossing"};
Expand Down Expand Up @@ -319,125 +319,124 @@ struct HfCorrelatorDplusHadrons {
corrBinning = {{binsZVtx, binsMultiplicity}, true};
}

template <typename ParticleContainer, typename AssocContainer>
void runMcGenDplusHadronAnalysis(const ParticleContainer& particlesToLoop, const AssocContainer& groupedMcParticles, int poolBin, int& counterDplusHadron)
{
for (const auto& particle : particlesToLoop) {
template <typename ParticleContainer, typename AssocContainer>
void runMcGenDplusHadronAnalysis(const ParticleContainer& particlesToLoop, const AssocContainer& groupedMcParticles, int poolBin, int& counterDplusHadron)
{
for (const auto& particle : particlesToLoop) {

if (std::abs(particle.pdgCode()) != Pdg::kDPlus) {
continue;
}
if (std::abs(particle.pdgCode()) != Pdg::kDPlus) {
continue;
}

if (std::abs(particle.flagMcMatchGen()) != hf_decay::hf_cand_3prong::DecayChannelMain::DplusToPiKPi) {
continue;
}
if (std::abs(particle.flagMcMatchGen()) != hf_decay::hf_cand_3prong::DecayChannelMain::DplusToPiKPi) {
continue;
}

double yD = RecoDecay::y(particle.pVector(), MassDPlus);
double yD = RecoDecay::y(particle.pVector(), MassDPlus);

if (std::abs(yD) > yCandGenMax ||
particle.pt() < ptCandMin ||
particle.pt() > ptCandMax) {
continue;
}
if (std::abs(yD) > yCandGenMax ||
particle.pt() < ptCandMin ||
particle.pt() > ptCandMax) {
continue;
}

std::vector<int> listDaughters{};
std::array<int, NDaughters> const arrDaughDplusPDG = {+kPiPlus, -kKPlus, kPiPlus};
std::array<int, NDaughters> prongsId{};
std::vector<int> listDaughters{};
std::array<int, NDaughters> const arrDaughDplusPDG = {+kPiPlus, -kKPlus, kPiPlus};
std::array<int, NDaughters> prongsId{};

RecoDecay::getDaughters(particle, &listDaughters, arrDaughDplusPDG, 2);
RecoDecay::getDaughters(particle, &listDaughters, arrDaughDplusPDG, 2);

if (listDaughters.size() != NDaughters) {
continue;
}
if (listDaughters.size() != NDaughters) {
continue;
}

bool isDaughtersOk = true;
int counterDaughters = 0;
bool isDaughtersOk = true;
int counterDaughters = 0;

for (const auto& dauIdx : listDaughters) {
auto daughI = particlesToLoop.rawIteratorAt(dauIdx - particlesToLoop.offset());
for (const auto& dauIdx : listDaughters) {
auto daughI = particlesToLoop.rawIteratorAt(dauIdx - particlesToLoop.offset());

if (std::abs(daughI.eta()) >= EtaDaughtersMax) {
isDaughtersOk = false;
break;
if (std::abs(daughI.eta()) >= EtaDaughtersMax) {
isDaughtersOk = false;
break;
}

prongsId[counterDaughters++] = daughI.globalIndex();
}

prongsId[counterDaughters++] = daughI.globalIndex();
}
if (!isDaughtersOk) { // Skip this D+ candidate if any daughter fails eta cut
continue;
}
counterDplusHadron++;

registry.fill(HIST("hDplusBin"), poolBin);
registry.fill(HIST("hPtCandMCGen"), particle.pt());
registry.fill(HIST("hEtaMcGen"), particle.eta());
registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf));
registry.fill(HIST("hYMCGen"), yD);

// Prompt / Non-prompt separation
bool isDplusPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt;
bool isDplusNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt;

if (isDplusPrompt) {
registry.fill(HIST("hPtCandMcGenPrompt"), particle.pt());
} else if (isDplusNonPrompt) {
registry.fill(HIST("hPtCandMcGenNonPrompt"), particle.pt());
}

if (!isDaughtersOk) { // Skip this D+ candidate if any daughter fails eta cut
continue;
}
counterDplusHadron++;

registry.fill(HIST("hDplusBin"), poolBin);
registry.fill(HIST("hPtCandMCGen"), particle.pt());
registry.fill(HIST("hEtaMcGen"), particle.eta());
registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf));
registry.fill(HIST("hYMCGen"), yD);

// Prompt / Non-prompt separation
bool isDplusPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt;
bool isDplusNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt;

if (isDplusPrompt) {
registry.fill(HIST("hPtCandMcGenPrompt"), particle.pt());
} else if (isDplusNonPrompt) {
registry.fill(HIST("hPtCandMcGenNonPrompt"), particle.pt());
}
// Count triggers
registry.fill(HIST("hcountDplustriggersMCGen"), 0, particle.pt());

// Count triggers
registry.fill(HIST("hcountDplustriggersMCGen"), 0, particle.pt());
for (const auto& particleAssoc : groupedMcParticles) {

for (const auto& particleAssoc : groupedMcParticles) {
if (std::abs(particleAssoc.eta()) > etaTrackMax ||
particleAssoc.pt() < ptTrackMin ||
particleAssoc.pt() > ptTrackMax) {
continue;
}

if (std::abs(particleAssoc.eta()) > etaTrackMax ||
particleAssoc.pt() < ptTrackMin ||
particleAssoc.pt() > ptTrackMax) {
continue;
}
// Remove daughters if requested
if (removeDaughters) {
if (particleAssoc.globalIndex() == prongsId[0] ||
particleAssoc.globalIndex() == prongsId[1] ||
particleAssoc.globalIndex() == prongsId[2]) {
continue;
}
}

// Remove daughters if requested
if (removeDaughters) {
if (particleAssoc.globalIndex() == prongsId[0] ||
particleAssoc.globalIndex() == prongsId[1] ||
particleAssoc.globalIndex() == prongsId[2]) {
// Particle species selection
if ((std::abs(particleAssoc.pdgCode()) != kElectron) &&
(std::abs(particleAssoc.pdgCode()) != kMuonMinus) &&
(std::abs(particleAssoc.pdgCode()) != kPiPlus) &&
(std::abs(particleAssoc.pdgCode()) != kKPlus) &&
(std::abs(particleAssoc.pdgCode()) != kProton)) {
continue;
}
}

// Particle species selection
if ((std::abs(particleAssoc.pdgCode()) != kElectron) &&
(std::abs(particleAssoc.pdgCode()) != kMuonMinus) &&
(std::abs(particleAssoc.pdgCode()) != kPiPlus) &&
(std::abs(particleAssoc.pdgCode()) != kKPlus) &&
(std::abs(particleAssoc.pdgCode()) != kProton)) {
continue;
}
if (!particleAssoc.isPhysicalPrimary()) {
continue;
}

if (!particleAssoc.isPhysicalPrimary()) {
continue;
}
int trackOrigin = RecoDecay::getCharmHadronOrigin(groupedMcParticles,
particleAssoc,
true);

int trackOrigin = RecoDecay::getCharmHadronOrigin(groupedMcParticles,
particleAssoc,
true);

registry.fill(HIST("hPtParticleAssocMcGen"), particleAssoc.pt());
entryDplusHadronPair(
getDeltaPhi(particleAssoc.phi(), particle.phi()),
particleAssoc.eta() - particle.eta(),
particle.pt(),
particleAssoc.pt(),
poolBin
);

entryDplusHadronRecoInfo(MassDPlus, true);
entryDplusHadronGenInfo(isDplusPrompt,
particleAssoc.isPhysicalPrimary(),
trackOrigin);
registry.fill(HIST("hPtParticleAssocMcGen"), particleAssoc.pt());
entryDplusHadronPair(
getDeltaPhi(particleAssoc.phi(), particle.phi()),
particleAssoc.eta() - particle.eta(),
particle.pt(),
particleAssoc.pt(),
poolBin);

entryDplusHadronRecoInfo(MassDPlus, true);
entryDplusHadronGenInfo(isDplusPrompt,
particleAssoc.isPhysicalPrimary(),
trackOrigin);
}
}
}
}

/// Dplus-hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via MC truth)
void processData(SelCollisionsWithDplus::iterator const& collision,
Expand Down Expand Up @@ -663,68 +662,67 @@ void runMcGenDplusHadronAnalysis(const ParticleContainer& particlesToLoop, const
}
PROCESS_SWITCH(HfCorrelatorDplusHadrons, processMcRec, "Process MC Reco mode", true);

/// Dplus-Hadron correlation pair builder - for MC gen-level analysis (no filter/selection, only true signal)
void processMcGen(CollisionsMc const& mcCollisions,
soa::Join<aod::Collisions, aod::FT0Mults, aod::EvSels, aod::McCollisionLabels> const& collisions,
CandDplusMcGen const& mcParticles)
{
BinningTypeMcGen const corrBinningMcGen{{binsZVtx, binsMultiplicityMc}, true};

for (const auto& mcCollision : mcCollisions) {
/// Dplus-Hadron correlation pair builder - for MC gen-level analysis (no filter/selection, only true signal)
void processMcGen(CollisionsMc const& mcCollisions,
soa::Join<aod::Collisions, aod::FT0Mults, aod::EvSels, aod::McCollisionLabels> const& collisions,
CandDplusMcGen const& mcParticles)
{
BinningTypeMcGen const corrBinningMcGen{{binsZVtx, binsMultiplicityMc}, true};

int counterDplusHadron = 0;
registry.fill(HIST("hMCEvtCount"), 0);
for (const auto& mcCollision : mcCollisions) {

int poolBin = corrBinningMcGen.getBin(std::make_tuple(mcCollision.posZ(), mcCollision.multMCFT0A()));
registry.fill(HIST("hMultFT0AMcGen"), mcCollision.multMCFT0A());
int counterDplusHadron = 0;
registry.fill(HIST("hMCEvtCount"), 0);

const auto groupedMcParticles = mcParticles.sliceBy(candMcGenPerMcCollision, mcCollision.globalIndex());
const auto groupedCollisions = collisions.sliceBy(recoCollisionsPerMcCollision, mcCollision.globalIndex());
int poolBin = corrBinningMcGen.getBin(std::make_tuple(mcCollision.posZ(), mcCollision.multMCFT0A()));
registry.fill(HIST("hMultFT0AMcGen"), mcCollision.multMCFT0A());

if (removeUnreconstructedGenCollisions) {
const auto groupedMcParticles = mcParticles.sliceBy(candMcGenPerMcCollision, mcCollision.globalIndex());
const auto groupedCollisions = collisions.sliceBy(recoCollisionsPerMcCollision, mcCollision.globalIndex());

if (groupedCollisions.size() < 1) {
continue;
}
if (removeUnreconstructedGenCollisions) {

if (groupedCollisions.size() > 1 && removeCollWSplitVtx) {
continue;
}

for (const auto& collision : groupedCollisions) {

if (useSel8 && !collision.sel8()) {
if (groupedCollisions.size() < 1) {
continue;
}

if (std::abs(collision.posZ()) > zVtxMax) {
if (groupedCollisions.size() > 1 && removeCollWSplitVtx) {
continue;
}

if (selNoSameBunchPileUpColl &&
!(collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup))) {
continue;
}
for (const auto& collision : groupedCollisions) {

if (!collision.has_mcCollision()) {
registry.fill(HIST("hFakeCollision"), 0.);
continue;
if (useSel8 && !collision.sel8()) {
continue;
}

if (std::abs(collision.posZ()) > zVtxMax) {
continue;
}

if (selNoSameBunchPileUpColl &&
!(collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup))) {
continue;
}

if (!collision.has_mcCollision()) {
registry.fill(HIST("hFakeCollision"), 0.);
continue;
}

// MC particles with reconstructed-collision selection
runMcGenDplusHadronAnalysis(groupedMcParticles, groupedMcParticles, poolBin, counterDplusHadron);
}

// MC particles with reconstructed-collision selection
} else {
// MC particles without reconstructed-collision selection (preliminary approval approach)
runMcGenDplusHadronAnalysis(groupedMcParticles, groupedMcParticles, poolBin, counterDplusHadron);
}

}
else {
// MC particles without reconstructed-collision selection (preliminary approval approach)
runMcGenDplusHadronAnalysis(groupedMcParticles, groupedMcParticles, poolBin, counterDplusHadron);
registry.fill(HIST("hcountDplusHadronPerEvent"), counterDplusHadron);
registry.fill(HIST("hZvtx"), mcCollision.posZ());
}

registry.fill(HIST("hcountDplusHadronPerEvent"), counterDplusHadron);
registry.fill(HIST("hZvtx"), mcCollision.posZ());
}
}
PROCESS_SWITCH(HfCorrelatorDplusHadrons, processMcGen, "Process MC Gen mode", false);

void processDataMixedEvent(SelCollisionsWithDplus const& collisions,
Expand Down
Loading