From 7031f0e4dd4020f188196ebc01bd0e8b319c7fb6 Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Thu, 18 Jun 2026 14:24:06 +0200 Subject: [PATCH 01/13] Added background computations for the k892hadronphoton --- .../Strangeness/sigma0builder.cxx | 356 ++++---- PWGLF/Tasks/Resonances/CMakeLists.txt | 5 + .../Tasks/Resonances/K892hadronphotonBkg.cxx | 767 ++++++++++++++++++ PWGLF/Tasks/Resonances/k892hadronphoton.cxx | 18 +- 4 files changed, 961 insertions(+), 185 deletions(-) create mode 100644 PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx index 86bf8e6172d..c3c04a272ea 100644 --- a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -18,6 +18,7 @@ // Comments, questions, complaints, suggestions? // Please write to: // gianni.shigeru.setoue.liveraro@cern.ch +// oussama.benchikhi@cern.ch // #include "PWGEM/PhotonMeson/Utils/MCUtilities.h" @@ -310,46 +311,48 @@ struct sigma0builder { Configurable mc_rapidityMax{"mc_rapidityMax", 0.5, "Max generated particle rapidity"}; } genSelections; - // Axis + struct : ConfigurableGroup { // base properties - ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 30.0f, 35.0f, 40.0f, 50.0f}, "pt axis for analysis"}; - ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f, 110.0f}, "Centrality"}; - ConfigurableAxis axisNch{"axisNch", {300, 0.0f, 3000.0f}, "N_{ch}"}; - - // Invariant Mass - ConfigurableAxis axisSigmaMass{"axisSigmaMass", {500, 1.10f, 1.30f}, "M_{#Sigma^{0}} (GeV/c^{2})"}; - ConfigurableAxis axisLambdaMass{"axisLambdaMass", {200, 1.101f, 1.131f}, "M_{#Lambda} (GeV/c^{2})"}; - ConfigurableAxis axisPhotonMass{"axisPhotonMass", {200, 0.0f, 0.3f}, "M_{#Gamma}"}; - ConfigurableAxis axisK0SMass{"axisK0SMass", {200, 0.4f, 0.6f}, "M_{K^{0}}"}; - ConfigurableAxis axisKStarMass{"axisKStarMass", {500, 0.6f, 1.6f}, "M_{K^{*}} (GeV/c^{2})"}; - - // AP plot axes - ConfigurableAxis axisAPAlpha{"axisAPAlpha", {220, -1.1f, 1.1f}, "V0 AP alpha"}; - ConfigurableAxis axisAPQt{"axisAPQt", {220, 0.0f, 0.5f}, "V0 AP alpha"}; - - // topological variable QA axes - ConfigurableAxis axisTPCrows{"axisTPCrows", {160, 0.0f, 160.0f}, "N TPC rows"}; - ConfigurableAxis axisNCls{"axisNCls", {8, -0.5, 7.5}, "NCls"}; - ConfigurableAxis axisTPCNSigma{"axisTPCNSigma", {40, -10, 10}, "TPC NSigma"}; - ConfigurableAxis axisDCAtoPV{"axisDCAtoPV", {500, 0.0f, 50.0f}, "DCA (cm)"}; - ConfigurableAxis axisXY{"axisXY", {120, -120.0f, 120.0f}, "XY axis"}; - ConfigurableAxis axisZ{"axisZ", {120, -120.0f, 120.0f}, "V0 Z position (cm)"}; - ConfigurableAxis axisDCAdau{"axisDCAdau", {50, 0.0f, 5.0f}, "DCA (cm)"}; - ConfigurableAxis axisCosPA{"axisCosPA", {200, 0.5f, 1.0f}, "Cosine of pointing angle"}; - ConfigurableAxis axisRadius{"axisRadius", {240, 0.0f, 120.0f}, "V0 radius (cm)"}; - ConfigurableAxis axisPhi{"axisPhi", {200, 0, 2 * o2::constants::math::PI}, "Phi for photons"}; - ConfigurableAxis axisPA{"axisPA", {100, 0.0f, 1}, "Pointing angle"}; - ConfigurableAxis axisRapidity{"axisRapidity", {100, -2.0f, 2.0f}, "Rapidity"}; - ConfigurableAxis axisCandSel{"axisCandSel", {15, 0.5f, +15.5f}, "Candidate Selection"}; - ConfigurableAxis axisIRBinning{"axisIRBinning", {151, -10, 1500}, "Binning for the interaction rate (kHz)"}; - ConfigurableAxis axisLifetime{"axisLifetime", {200, 0, 50}, "Lifetime"}; - - // EMCal-specifc - ConfigurableAxis axisClrDefinition{"axisClrDefinition", {51, -0.5, 50.5}, "Cluster Definition"}; - ConfigurableAxis axisClrNCells{"axisClrNCells", {25, 0.0, 25}, "N cells per cluster"}; - ConfigurableAxis axisClrEnergy{"axisClrEnergy", {400, 0.0, 10}, "Energy per cluster"}; - ConfigurableAxis axisClrTime{"axisClrTime", {300, -30.0, 30.0}, "cluster time (ns)"}; - ConfigurableAxis axisClrShape{"axisClrShape", {100, 0.0, 1.0}, "cluster shape"}; + std::string prefix = "axisConfig"; // JSON group name + ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 30.0f, 35.0f, 40.0f, 50.0f}, "pt axis for analysis"}; + ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f, 110.0f}, "Centrality"}; + ConfigurableAxis axisNch{"axisNch", {300, 0.0f, 3000.0f}, "N_{ch}"}; + + // Invariant Mass + ConfigurableAxis axisSigmaMass{"axisSigmaMass", {500, 1.10f, 1.30f}, "M_{#Sigma^{0}} (GeV/c^{2})"}; + ConfigurableAxis axisLambdaMass{"axisLambdaMass", {200, 1.101f, 1.131f}, "M_{#Lambda} (GeV/c^{2})"}; + ConfigurableAxis axisPhotonMass{"axisPhotonMass", {200, 0.0f, 0.3f}, "M_{#Gamma}"}; + ConfigurableAxis axisK0SMass{"axisK0SMass", {200, 0.4f, 0.6f}, "M_{K^{0}}"}; + ConfigurableAxis axisKStarMass{"axisKStarMass", {500, 0.6f, 1.6f}, "M_{K^{*}} (GeV/c^{2})"}; + + // AP plot axes + ConfigurableAxis axisAPAlpha{"axisAPAlpha", {220, -1.1f, 1.1f}, "V0 AP alpha"}; + ConfigurableAxis axisAPQt{"axisAPQt", {220, 0.0f, 0.5f}, "V0 AP alpha"}; + + // topological variable QA axes + ConfigurableAxis axisTPCrows{"axisTPCrows", {160, 0.0f, 160.0f}, "N TPC rows"}; + ConfigurableAxis axisNCls{"axisNCls", {8, -0.5, 7.5}, "NCls"}; + ConfigurableAxis axisTPCNSigma{"axisTPCNSigma", {40, -10, 10}, "TPC NSigma"}; + ConfigurableAxis axisDCAtoPV{"axisDCAtoPV", {500, 0.0f, 50.0f}, "DCA (cm)"}; + ConfigurableAxis axisXY{"axisXY", {120, -120.0f, 120.0f}, "XY axis"}; + ConfigurableAxis axisZ{"axisZ", {120, -120.0f, 120.0f}, "V0 Z position (cm)"}; + ConfigurableAxis axisDCAdau{"axisDCAdau", {50, 0.0f, 5.0f}, "DCA (cm)"}; + ConfigurableAxis axisCosPA{"axisCosPA", {200, 0.5f, 1.0f}, "Cosine of pointing angle"}; + ConfigurableAxis axisRadius{"axisRadius", {240, 0.0f, 120.0f}, "V0 radius (cm)"}; + ConfigurableAxis axisPhi{"axisPhi", {200, 0, 2 * o2::constants::math::PI}, "Phi for photons"}; + ConfigurableAxis axisPA{"axisPA", {100, 0.0f, 1}, "Pointing angle"}; + ConfigurableAxis axisRapidity{"axisRapidity", {100, -2.0f, 2.0f}, "Rapidity"}; + ConfigurableAxis axisCandSel{"axisCandSel", {15, 0.5f, +15.5f}, "Candidate Selection"}; + ConfigurableAxis axisIRBinning{"axisIRBinning", {151, -10, 1500}, "Binning for the interaction rate (kHz)"}; + ConfigurableAxis axisLifetime{"axisLifetime", {200, 0, 50}, "Lifetime"}; + + // EMCal-specifc + ConfigurableAxis axisClrDefinition{"axisClrDefinition", {51, -0.5, 50.5}, "Cluster Definition"}; + ConfigurableAxis axisClrNCells{"axisClrNCells", {25, 0.0, 25}, "N cells per cluster"}; + ConfigurableAxis axisClrEnergy{"axisClrEnergy", {400, 0.0, 10}, "Energy per cluster"}; + ConfigurableAxis axisClrTime{"axisClrTime", {300, -30.0, 30.0}, "cluster time (ns)"}; + ConfigurableAxis axisClrShape{"axisClrShape", {100, 0.0, 1.0}, "cluster shape"}; + } axisConfig; void init(InitContext const&) { @@ -371,7 +374,7 @@ struct sigma0builder { ccdb->setCaching(true); ccdb->setFatalWhenNull(false); - histos.add("hEventCentrality", "hEventCentrality", kTH1D, {axisCentrality}); + histos.add("hEventCentrality", "hEventCentrality", kTH1D, {axisConfig.axisCentrality}); if (eventSelections.fUseEventSelection) { histos.add("hEventSelection", "hEventSelection", kTH1D, {{21, -0.5f, +20.5f}}); @@ -400,11 +403,11 @@ struct sigma0builder { } histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(19, "Below min IR"); histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(20, "Above max IR"); - + if (fGetIR) { histos.add("GeneralQA/hRunNumberNegativeIR", "", kTH1D, {{1, 0., 1.}}); - histos.add("GeneralQA/hInteractionRate", "hInteractionRate", kTH1D, {axisIRBinning}); - histos.add("GeneralQA/hCentralityVsInteractionRate", "hCentralityVsInteractionRate", kTH2D, {axisCentrality, axisIRBinning}); + histos.add("GeneralQA/hInteractionRate", "hInteractionRate", kTH1D, {axisConfig.axisIRBinning}); + histos.add("GeneralQA/hCentralityVsInteractionRate", "hCentralityVsInteractionRate", kTH2D, {axisConfig.axisCentrality, axisConfig.axisIRBinning}); } } @@ -418,51 +421,51 @@ struct sigma0builder { continue; } - histos.add(histodir + "/hpT", "hpT", kTH1D, {axisPt}); + histos.add(histodir + "/hpT", "hpT", kTH1D, {axisConfig.axisPt}); histos.add(histodir + "/hV0Type", "hV0Type", kTH1D, {{8, 0.5f, 8.5f}}); - histos.add(histodir + "/hNegEta", "hNegEta", kTH1D, {axisRapidity}); - histos.add(histodir + "/hPosEta", "hPosEta", kTH1D, {axisRapidity}); - histos.add(histodir + "/hDCANegToPV", "hDCANegToPV", kTH1D, {axisDCAtoPV}); - histos.add(histodir + "/hDCAPosToPV", "hDCAPosToPV", kTH1D, {axisDCAtoPV}); - histos.add(histodir + "/hDCADau", "hnDCADau", kTH1D, {axisDCAdau}); - histos.add(histodir + "/hRadius", "hnRadius", kTH1D, {axisRadius}); - histos.add(histodir + "/hZ", "hZ", kTH1D, {axisZ}); - histos.add(histodir + "/hCosPA", "hCosPA", kTH1D, {axisCosPA}); - histos.add(histodir + "/hPhi", "hPhi", kTH1D, {axisPhi}); - histos.add(histodir + "/hPosTPCCR", "hPosTPCCR", kTH1D, {axisTPCrows}); - histos.add(histodir + "/hNegTPCCR", "hNegTPCCR", kTH1D, {axisTPCrows}); - histos.add(histodir + "/hPosITSNCls", "hPosITSNCls", kTH1D, {axisNCls}); - histos.add(histodir + "/hNegITSNCls", "hNegITSNCls", kTH1D, {axisNCls}); - histos.add(histodir + "/hPosTPCNSigmaEl", "hPosTPCNSigmaEl", kTH1D, {axisTPCNSigma}); - histos.add(histodir + "/hNegTPCNSigmaEl", "hNegTPCNSigmaEl", kTH1D, {axisTPCNSigma}); - histos.add(histodir + "/hPosTPCNSigmaPi", "hPosTPCNSigmaPi", kTH1D, {axisTPCNSigma}); - histos.add(histodir + "/hNegTPCNSigmaPi", "hNegTPCNSigmaPi", kTH1D, {axisTPCNSigma}); - histos.add(histodir + "/hPosTPCNSigmaPr", "hPosTPCNSigmaPr", kTH1D, {axisTPCNSigma}); - histos.add(histodir + "/hNegTPCNSigmaPr", "hNegTPCNSigmaPr", kTH1D, {axisTPCNSigma}); - histos.add(histodir + "/h2dArmenteros", "h2dArmenteros", kTH2D, {axisAPAlpha, axisAPQt}); - - histos.add(histodir + "/hPhotonY", "hPhotonY", kTH1D, {axisRapidity}); - histos.add(histodir + "/hPhotonMass", "hPhotonMass", kTH1D, {axisPhotonMass}); - histos.add(histodir + "/h2dMassPhotonVsK0S", "h2dMassPhotonVsK0S", kTH2D, {axisPhotonMass, axisK0SMass}); - histos.add(histodir + "/h2dMassPhotonVsLambda", "h2dMassPhotonVsLambda", kTH2D, {axisPhotonMass, axisLambdaMass}); - histos.add(histodir + "/hLambdaLifeTime", "hLambdaLifeTime", kTH1D, {axisLifetime}); - histos.add(histodir + "/hLambdaY", "hLambdaY", kTH1D, {axisRapidity}); - histos.add(histodir + "/hLambdaMass", "hLambdaMass", kTH1D, {axisLambdaMass}); - histos.add(histodir + "/hALambdaMass", "hALambdaMass", kTH1D, {axisLambdaMass}); - histos.add(histodir + "/h2dMassLambdaVsK0S", "h2dMassLambdaVsK0S", kTH2D, {axisLambdaMass, axisK0SMass}); - histos.add(histodir + "/h2dMassLambdaVsGamma", "h2dMassLambdaVsGamma", kTH2D, {axisLambdaMass, axisPhotonMass}); - histos.add(histodir + "/hKShortLifeTime", "hKShortLifeTime", kTH1D, {axisLifetime}); - histos.add(histodir + "/hKShortY", "hKShortY", kTH1D, {axisRapidity}); - histos.add(histodir + "/hKShortMass", "hKShortMass", kTH1D, {axisK0SMass}); - histos.add(histodir + "/h2dMassK0SvsLambda", "h2dMassK0SvsLambda", kTH2D, {axisK0SMass, axisLambdaMass}); - histos.add(histodir + "/h2dMassK0SVsGamma", "h2dMassK0SVsGamma", kTH2D, {axisK0SMass, axisPhotonMass}); + histos.add(histodir + "/hNegEta", "hNegEta", kTH1D, {axisConfig.axisRapidity}); + histos.add(histodir + "/hPosEta", "hPosEta", kTH1D, {axisConfig.axisRapidity}); + histos.add(histodir + "/hDCANegToPV", "hDCANegToPV", kTH1D, {axisConfig.axisDCAtoPV}); + histos.add(histodir + "/hDCAPosToPV", "hDCAPosToPV", kTH1D, {axisConfig.axisDCAtoPV}); + histos.add(histodir + "/hDCADau", "hnDCADau", kTH1D, {axisConfig.axisDCAdau}); + histos.add(histodir + "/hRadius", "hnRadius", kTH1D, {axisConfig.axisRadius}); + histos.add(histodir + "/hZ", "hZ", kTH1D, {axisConfig.axisZ}); + histos.add(histodir + "/hCosPA", "hCosPA", kTH1D, {axisConfig.axisCosPA}); + histos.add(histodir + "/hPhi", "hPhi", kTH1D, {axisConfig.axisPhi}); + histos.add(histodir + "/hPosTPCCR", "hPosTPCCR", kTH1D, {axisConfig.axisTPCrows}); + histos.add(histodir + "/hNegTPCCR", "hNegTPCCR", kTH1D, {axisConfig.axisTPCrows}); + histos.add(histodir + "/hPosITSNCls", "hPosITSNCls", kTH1D, {axisConfig.axisNCls}); + histos.add(histodir + "/hNegITSNCls", "hNegITSNCls", kTH1D, {axisConfig.axisNCls}); + histos.add(histodir + "/hPosTPCNSigmaEl", "hPosTPCNSigmaEl", kTH1D, {axisConfig.axisTPCNSigma}); + histos.add(histodir + "/hNegTPCNSigmaEl", "hNegTPCNSigmaEl", kTH1D, {axisConfig.axisTPCNSigma}); + histos.add(histodir + "/hPosTPCNSigmaPi", "hPosTPCNSigmaPi", kTH1D, {axisConfig.axisTPCNSigma}); + histos.add(histodir + "/hNegTPCNSigmaPi", "hNegTPCNSigmaPi", kTH1D, {axisConfig.axisTPCNSigma}); + histos.add(histodir + "/hPosTPCNSigmaPr", "hPosTPCNSigmaPr", kTH1D, {axisConfig.axisTPCNSigma}); + histos.add(histodir + "/hNegTPCNSigmaPr", "hNegTPCNSigmaPr", kTH1D, {axisConfig.axisTPCNSigma}); + histos.add(histodir + "/h2dArmenteros", "h2dArmenteros", kTH2D, {axisConfig.axisAPAlpha, axisConfig.axisAPQt}); + + histos.add(histodir + "/hPhotonY", "hPhotonY", kTH1D, {axisConfig.axisRapidity}); + histos.add(histodir + "/hPhotonMass", "hPhotonMass", kTH1D, {axisConfig.axisPhotonMass}); + histos.add(histodir + "/h2dMassPhotonVsK0S", "h2dMassPhotonVsK0S", kTH2D, {axisConfig.axisPhotonMass, axisConfig.axisK0SMass}); + histos.add(histodir + "/h2dMassPhotonVsLambda", "h2dMassPhotonVsLambda", kTH2D, {axisConfig.axisPhotonMass, axisConfig.axisLambdaMass}); + histos.add(histodir + "/hLambdaLifeTime", "hLambdaLifeTime", kTH1D, {axisConfig.axisLifetime}); + histos.add(histodir + "/hLambdaY", "hLambdaY", kTH1D, {axisConfig.axisRapidity}); + histos.add(histodir + "/hLambdaMass", "hLambdaMass", kTH1D, {axisConfig.axisLambdaMass}); + histos.add(histodir + "/hALambdaMass", "hALambdaMass", kTH1D, {axisConfig.axisLambdaMass}); + histos.add(histodir + "/h2dMassLambdaVsK0S", "h2dMassLambdaVsK0S", kTH2D, {axisConfig.axisLambdaMass, axisConfig.axisK0SMass}); + histos.add(histodir + "/h2dMassLambdaVsGamma", "h2dMassLambdaVsGamma", kTH2D, {axisConfig.axisLambdaMass, axisConfig.axisPhotonMass}); + histos.add(histodir + "/hKShortLifeTime", "hKShortLifeTime", kTH1D, {axisConfig.axisLifetime}); + histos.add(histodir + "/hKShortY", "hKShortY", kTH1D, {axisConfig.axisRapidity}); + histos.add(histodir + "/hKShortMass", "hKShortMass", kTH1D, {axisConfig.axisK0SMass}); + histos.add(histodir + "/h2dMassK0SvsLambda", "h2dMassK0SvsLambda", kTH2D, {axisConfig.axisK0SMass, axisConfig.axisLambdaMass}); + histos.add(histodir + "/h2dMassK0SVsGamma", "h2dMassK0SVsGamma", kTH2D, {axisConfig.axisK0SMass, axisConfig.axisPhotonMass}); if (histodir != "V0BeforeSel" && fFillV03DPositionHistos) // We dont want this for all reco v0s! - histos.add(histodir + "/h3dV0XYZ", "h3dV0XYZ", kTH3D, {axisXY, axisXY, axisZ}); + histos.add(histodir + "/h3dV0XYZ", "h3dV0XYZ", kTH3D, {axisConfig.axisXY, axisConfig.axisXY, axisConfig.axisZ}); } if (fUsePCMPhoton || doprocessPCMVsEMCalQA) { - histos.add("PhotonSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisCandSel}); + histos.add("PhotonSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisConfig.axisCandSel}); histos.get(HIST("PhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(1, "No Sel"); histos.get(HIST("PhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(2, "Mass"); histos.get(HIST("PhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(3, "Y"); @@ -478,7 +481,7 @@ struct sigma0builder { histos.get(HIST("PhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(13, "TPC NSigma"); if (doprocessPCMVsEMCalQA) { - histos.add("EMCalPhotonSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisCandSel}); + histos.add("EMCalPhotonSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisConfig.axisCandSel}); histos.get(HIST("EMCalPhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(1, "No Sel"); histos.get(HIST("EMCalPhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(2, "Definition"); histos.get(HIST("EMCalPhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(3, "MinCell"); @@ -491,16 +494,16 @@ struct sigma0builder { } else { for (const auto& histodir : DirList2) { - histos.add(histodir + "/hDefinition", "hDefinition", kTH1D, {axisClrDefinition}); - histos.add(histodir + "/h2dNCells", "h2dNCells", kTH2D, {axisPt, axisClrNCells}); - histos.add(histodir + "/h2dEnergy", "h2dEnergy", kTH2D, {axisPt, axisClrEnergy}); - histos.add(histodir + "/h2dEtaVsPhi", "h2dEtaVsPhi", kTH2D, {axisRapidity, axisPhi}); - histos.add(histodir + "/h2dTime", "h2dTime", kTH2D, {axisPt, axisClrTime}); + histos.add(histodir + "/hDefinition", "hDefinition", kTH1D, {axisConfig.axisClrDefinition}); + histos.add(histodir + "/h2dNCells", "h2dNCells", kTH2D, {axisConfig.axisPt, axisConfig.axisClrNCells}); + histos.add(histodir + "/h2dEnergy", "h2dEnergy", kTH2D, {axisConfig.axisPt, axisConfig.axisClrEnergy}); + histos.add(histodir + "/h2dEtaVsPhi", "h2dEtaVsPhi", kTH2D, {axisConfig.axisRapidity, axisConfig.axisPhi}); + histos.add(histodir + "/h2dTime", "h2dTime", kTH2D, {axisConfig.axisPt, axisConfig.axisClrTime}); histos.add(histodir + "/hExotic", "hExotic", kTH1D, {{2, -0.5f, 1.5f}}); - histos.add(histodir + "/h2dShape", "h2dShape", kTH2D, {axisPt, axisClrShape}); + histos.add(histodir + "/h2dShape", "h2dShape", kTH2D, {axisConfig.axisPt, axisConfig.axisClrShape}); } - histos.add("EMCalPhotonSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisCandSel}); + histos.add("EMCalPhotonSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisConfig.axisCandSel}); histos.get(HIST("EMCalPhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(1, "No Sel"); histos.get(HIST("EMCalPhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(2, "Definition"); histos.get(HIST("EMCalPhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(3, "MinCell"); @@ -511,7 +514,7 @@ struct sigma0builder { histos.get(HIST("EMCalPhotonSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(8, "Shape"); } - histos.add("LambdaSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisCandSel}); + histos.add("LambdaSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisConfig.axisCandSel}); histos.get(HIST("LambdaSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(1, "No Sel"); histos.get(HIST("LambdaSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(2, "Mass"); histos.get(HIST("LambdaSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(3, "Y"); @@ -527,7 +530,7 @@ struct sigma0builder { histos.get(HIST("LambdaSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(13, "ITSNCls"); histos.get(HIST("LambdaSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(14, "Lifetime"); - histos.add("KShortSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisCandSel}); + histos.add("KShortSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisConfig.axisCandSel}); histos.get(HIST("KShortSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(1, "No Sel"); histos.get(HIST("KShortSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(2, "Mass"); histos.get(HIST("KShortSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(3, "Y"); @@ -545,37 +548,38 @@ struct sigma0builder { if (doprocessRealData || doprocessRealDataWithTOF || doprocessRealDataWithEMCal || doprocessMonteCarlo || doprocessMonteCarloWithTOF || doprocessMonteCarloWithEMCal) { histos.add("SigmaSel/hSigma0DauDeltaIndex", "hSigma0DauDeltaIndex", kTH1F, {{100, -49.5f, 50.5f}}); - histos.add("SigmaSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisCandSel}); + histos.add("SigmaSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisConfig.axisCandSel}); histos.get(HIST("SigmaSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(1, "No Sel"); histos.get(HIST("SigmaSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(2, "Sigma Mass Window"); histos.get(HIST("SigmaSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(3, "Sigma Y Window"); - histos.add("SigmaSel/hSigmaMassBeforeSel", "hSigmaMassBeforeSel", kTH1F, {axisSigmaMass}); - histos.add("SigmaSel/hSigmaMassSelected", "hSigmaMassSelected", kTH1F, {axisSigmaMass}); + histos.add("SigmaSel/hSigmaMassBeforeSel", "hSigmaMassBeforeSel", kTH1F, {axisConfig.axisSigmaMass}); + histos.add("SigmaSel/hSigmaMassSelected", "hSigmaMassSelected", kTH1F, {axisConfig.axisSigmaMass}); - histos.add("KStarSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisCandSel}); + histos.add("KStarSel/hSelectionStatistics", "hSelectionStatistics", kTH1D, {axisConfig.axisCandSel}); histos.get(HIST("KStarSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(1, "No Sel"); histos.get(HIST("KStarSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(2, "KStar Mass Window"); histos.get(HIST("KStarSel/hSelectionStatistics"))->GetXaxis()->SetBinLabel(3, "KStar Y Window"); - histos.add("KStarSel/hKStarMassSelected", "hKStarMassSelected", kTH1F, {axisKStarMass}); + histos.add("KStarSel/hKStarMassSelected", "hKStarMassSelected", kTH1F, {axisConfig.axisKStarMass}); } if (doAssocStudy && (doprocessMonteCarlo || doprocessMonteCarloWithTOF)) { - histos.add("V0AssoQA/h2dIRVsPt_TrueGamma", "h2dIRVsPt_TrueGamma", kTH2F, {axisIRBinning, axisPt}); - histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueGamma", "h3dPAVsIRVsPt_TrueGamma", kTH3F, {axisPA, axisIRBinning, axisPt}); - histos.add("V0AssoQA/h2dIRVsPt_TrueGamma_BadCollAssig", "h2dIRVsPt_TrueGamma_BadCollAssig", kTH2F, {axisIRBinning, axisPt}); - histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueGamma_BadCollAssig", "h3dPAVsIRVsPt_TrueGamma_BadCollAssig", kTH3F, {axisPA, axisIRBinning, axisPt}); + histos.add("V0AssoQA/h2dIRVsPt_TrueGamma", "h2dIRVsPt_TrueGamma", kTH2F, {axisConfig.axisIRBinning, axisConfig.axisPt}); + histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueGamma", "h3dPAVsIRVsPt_TrueGamma", kTH3F, {axisConfig.axisPA, axisConfig.axisIRBinning, axisConfig.axisPt}); + histos.add("V0AssoQA/h2dIRVsPt_TrueGamma_BadCollAssig", "h2dIRVsPt_TrueGamma_BadCollAssig", kTH2F, {axisConfig.axisIRBinning, axisConfig.axisPt}); + histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueGamma_BadCollAssig", "h3dPAVsIRVsPt_TrueGamma_BadCollAssig", kTH3F, {axisConfig.axisPA, axisConfig.axisIRBinning, axisConfig.axisPt}); - histos.add("V0AssoQA/h2dIRVsPt_TrueLambda", "h2dIRVsPt_TrueLambda", kTH2F, {axisIRBinning, axisPt}); - histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueLambda", "h3dPAVsIRVsPt_TrueLambda", kTH3F, {axisPA, axisIRBinning, axisPt}); - histos.add("V0AssoQA/h2dIRVsPt_TrueLambda_BadCollAssig", "h2dIRVsPt_TrueLambda_BadCollAssig", kTH2F, {axisIRBinning, axisPt}); - histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueLambda_BadCollAssig", "h3dPAVsIRVsPt_TrueLambda_BadCollAssig", kTH3F, {axisPA, axisIRBinning, axisPt}); + histos.add("V0AssoQA/h2dIRVsPt_TrueLambda", "h2dIRVsPt_TrueLambda", kTH2F, {axisConfig.axisIRBinning, axisConfig.axisPt}); + histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueLambda", "h3dPAVsIRVsPt_TrueLambda", kTH3F, {axisConfig.axisPA, axisConfig.axisIRBinning, axisConfig.axisPt}); + histos.add("V0AssoQA/h2dIRVsPt_TrueLambda_BadCollAssig", "h2dIRVsPt_TrueLambda_BadCollAssig", kTH2F, {axisConfig.axisIRBinning, axisConfig.axisPt}); + histos.add("V0AssoQA/h3dPAVsIRVsPt_TrueLambda_BadCollAssig", "h3dPAVsIRVsPt_TrueLambda_BadCollAssig", kTH3F, {axisConfig.axisPA, axisConfig.axisIRBinning, axisConfig.axisPt}); } // MC if (doprocessMonteCarlo || doprocessMonteCarloWithTOF || doprocessMonteCarloWithEMCal) { histos.add("MCQA/h2dPhotonNMothersVsPDG", "h2dPhotonNMothersVsPDG", kTHnSparseD, {{10, -0.5f, +9.5f}, {10001, -5000.5f, +5000.5f}}); + histos.add("MCQA/h2dTrueDaughtersMatrix", "h2dTrueDaughtersMatrix", kTHnSparseD, {{10001, -5000.5f, +5000.5f}, {10001, -5000.5f, +5000.5f}}); histos.add("MCQA/h2dPhotonNMothersVsMCProcess", "h2dPhotonNMothersVsMCProcess", kTH2D, {{10, -0.5f, +9.5f}, {50, -0.5f, 49.5f}}); histos.add("MCQA/hPhotonMotherSize", "hPhotonMotherSize", kTH1D, {{10, -0.5f, +9.5f}}); histos.add("MCQA/hPhotonMCProcess", "hPhotonMCProcess", kTH1D, {{50, -0.5f, 49.5f}}); @@ -603,33 +607,33 @@ struct sigma0builder { } if (doprocessPCMVsEMCalQA) { - histos.add("PhotonMCQA/hPCMPhotonMCpT", "hPCMPhotonMCpT", kTH1D, {axisPt}); - histos.add("PhotonMCQA/h2dPCMPhotonMCpTResolution", "h2dPCMPhotonMCpTResolution", kTH2D, {axisPt, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/hPCMSigma0PhotonMCpT", "hPCMSigma0PhotonMCpT", kTH1D, {axisPt}); - histos.add("PhotonMCQA/h2dPCMSigma0PhotonMCpTResolution", "h2dPCMSigma0PhotonMCpTResolution", kTH2D, {axisPt, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/hPCMPhotonMCpT", "hPCMPhotonMCpT", kTH1D, {axisConfig.axisPt}); + histos.add("PhotonMCQA/h2dPCMPhotonMCpTResolution", "h2dPCMPhotonMCpTResolution", kTH2D, {axisConfig.axisPt, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/hPCMSigma0PhotonMCpT", "hPCMSigma0PhotonMCpT", kTH1D, {axisConfig.axisPt}); + histos.add("PhotonMCQA/h2dPCMSigma0PhotonMCpTResolution", "h2dPCMSigma0PhotonMCpTResolution", kTH2D, {axisConfig.axisPt, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/hEMCalPhotonMCpT", "hEMCalPhotonMCpT", kTH1D, {axisPt}); - histos.add("PhotonMCQA/h2dEMCalPhotonMCpTResolution", "h2dEMCalPhotonMCpTResolution", kTH2D, {axisPt, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/h2dEMCalPhotonMCEnergyResolution", "h2dEMCalPhotonMCEnergyResolution", kTH2D, {axisClrEnergy, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/h2dEMCalPhotonMCEtaResolution", "h2dEMCalPhotonMCEtaResolution", kTH2D, {axisRapidity, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/h2dEMCalPhotonMCPhiResolution", "h2dEMCalPhotonMCPhiResolution", kTH2D, {axisPhi, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/h2dEMCalPhotonMCFractionEnergy", "h2dEMCalPhotonMCFractionEnergy", kTH2D, {axisPt, {100, -1.0f, 1.0f}}); + histos.add("PhotonMCQA/hEMCalPhotonMCpT", "hEMCalPhotonMCpT", kTH1D, {axisConfig.axisPt}); + histos.add("PhotonMCQA/h2dEMCalPhotonMCpTResolution", "h2dEMCalPhotonMCpTResolution", kTH2D, {axisConfig.axisPt, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/h2dEMCalPhotonMCEnergyResolution", "h2dEMCalPhotonMCEnergyResolution", kTH2D, {axisConfig.axisClrEnergy, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/h2dEMCalPhotonMCEtaResolution", "h2dEMCalPhotonMCEtaResolution", kTH2D, {axisConfig.axisRapidity, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/h2dEMCalPhotonMCPhiResolution", "h2dEMCalPhotonMCPhiResolution", kTH2D, {axisConfig.axisPhi, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/h2dEMCalPhotonMCFractionEnergy", "h2dEMCalPhotonMCFractionEnergy", kTH2D, {axisConfig.axisPt, {100, -1.0f, 1.0f}}); - histos.add("PhotonMCQA/hEMCalSigma0PhotonMCpT", "hEMCalSigma0PhotonMCpT", kTH1D, {axisPt}); - histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCpTResolution", "h2dEMCalSigma0PhotonMCpTResolution", kTH2D, {axisPt, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCEnergyResolution", "h2dEMCalSigma0PhotonMCEnergyResolution", kTH2D, {axisClrEnergy, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCEtaResolution", "h2dEMCalSigma0PhotonMCEtaResolution", kTH2D, {axisRapidity, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCPhiResolution", "h2dEMCalSigma0PhotonMCPhiResolution", kTH2D, {axisPhi, {100, -2.0f, 2.0f}}); - histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCFractionEnergy", "h2dEMCalSigma0PhotonMCFractionEnergy", kTH2D, {axisPt, {100, -1.0f, 1.0f}}); + histos.add("PhotonMCQA/hEMCalSigma0PhotonMCpT", "hEMCalSigma0PhotonMCpT", kTH1D, {axisConfig.axisPt}); + histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCpTResolution", "h2dEMCalSigma0PhotonMCpTResolution", kTH2D, {axisConfig.axisPt, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCEnergyResolution", "h2dEMCalSigma0PhotonMCEnergyResolution", kTH2D, {axisConfig.axisClrEnergy, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCEtaResolution", "h2dEMCalSigma0PhotonMCEtaResolution", kTH2D, {axisConfig.axisRapidity, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCPhiResolution", "h2dEMCalSigma0PhotonMCPhiResolution", kTH2D, {axisConfig.axisPhi, {100, -2.0f, 2.0f}}); + histos.add("PhotonMCQA/h2dEMCalSigma0PhotonMCFractionEnergy", "h2dEMCalSigma0PhotonMCFractionEnergy", kTH2D, {axisConfig.axisPt, {100, -1.0f, 1.0f}}); - histos.add("PhotonMCQA/hGenPhoton", "hGenPhoton", kTH1D, {axisPt}); - histos.add("PhotonMCQA/hGenSigma0Photon", "hGenSigma0Photon", kTH1D, {axisPt}); + histos.add("PhotonMCQA/hGenPhoton", "hGenPhoton", kTH1D, {axisConfig.axisPt}); + histos.add("PhotonMCQA/hGenSigma0Photon", "hGenSigma0Photon", kTH1D, {axisConfig.axisPt}); } if (doprocessGeneratedRun3 && genSelections.doQA) { // Pi0s - histos.add("GenQA/hGenPi0", "hGenPi0", kTH1D, {axisPt}); + histos.add("GenQA/hGenPi0", "hGenPi0", kTH1D, {axisConfig.axisPt}); auto hPrimaryPi0s = histos.add("GenQA/hPrimaryPi0s", "hPrimaryPi0s", kTH1D, {{2, -0.5f, 1.5f}}); hPrimaryPi0s->GetXaxis()->SetBinLabel(1, "All Pi0s"); @@ -646,16 +650,16 @@ struct sigma0builder { // ______________________________________________________ // Sigma0s - histos.add("GenQA/hGenSigma0", "hGenSigma0", kTH1D, {axisPt}); - histos.add("GenQA/hGenAntiSigma0", "hGenAntiSigma0", kTH1D, {axisPt}); + histos.add("GenQA/hGenSigma0", "hGenSigma0", kTH1D, {axisConfig.axisPt}); + histos.add("GenQA/hGenAntiSigma0", "hGenAntiSigma0", kTH1D, {axisConfig.axisPt}); - histos.add("GenQA/h3dGenSigma0_pTMap", "h3dGenSigma0_pTMap", kTH3D, {axisPt, axisPt, axisPt}); - histos.add("GenQA/h3dGenASigma0_pTMap", "h3dGenASigma0_pTMap", kTH3D, {axisPt, axisPt, axisPt}); + histos.add("GenQA/h3dGenSigma0_pTMap", "h3dGenSigma0_pTMap", kTH3D, {axisConfig.axisPt, axisConfig.axisPt, axisConfig.axisPt}); + histos.add("GenQA/h3dGenASigma0_pTMap", "h3dGenASigma0_pTMap", kTH3D, {axisConfig.axisPt, axisConfig.axisPt, axisConfig.axisPt}); - histos.add("GenQA/h2dGenSigma0xy_Generator", "hGenSigma0xy_Generator", kTH2D, {axisXY, axisXY}); - histos.add("GenQA/h2dGenSigma0xy_Transport", "hGenSigma0xy_Transport", kTH2D, {axisXY, axisXY}); - histos.add("GenQA/hGenSigma0Radius_Generator", "hGenSigma0Radius_Generator", kTH1D, {axisRadius}); - histos.add("GenQA/hGenSigma0Radius_Transport", "hGenSigma0Radius_Transport", kTH1D, {axisRadius}); + histos.add("GenQA/h2dGenSigma0xy_Generator", "hGenSigma0xy_Generator", kTH2D, {axisConfig.axisXY, axisConfig.axisXY}); + histos.add("GenQA/h2dGenSigma0xy_Transport", "hGenSigma0xy_Transport", kTH2D, {axisConfig.axisXY, axisConfig.axisXY}); + histos.add("GenQA/hGenSigma0Radius_Generator", "hGenSigma0Radius_Generator", kTH1D, {axisConfig.axisRadius}); + histos.add("GenQA/hGenSigma0Radius_Transport", "hGenSigma0Radius_Transport", kTH1D, {axisConfig.axisRadius}); histos.add("GenQA/h2dSigma0MCSourceVsPDGMother", "h2dSigma0MCSourceVsPDGMother", kTHnSparseD, {{2, -0.5f, 1.5f}, {10001, -5000.5f, +5000.5f}}); histos.add("GenQA/h2dSigma0NDaughtersVsPDG", "h2dSigma0NDaughtersVsPDG", kTHnSparseD, {{10, -0.5f, +9.5f}, {10001, -5000.5f, +5000.5f}}); @@ -681,12 +685,12 @@ struct sigma0builder { // ______________________________________________________ // KStar - histos.add("GenQA/hGenKStar", "hGenKStar", kTH1D, {axisPt}); + histos.add("GenQA/hGenKStar", "hGenKStar", kTH1D, {axisConfig.axisPt}); - histos.add("GenQA/h2dGenKStarxy_Generator", "hGenKStarxy_Generator", kTH2D, {axisXY, axisXY}); - histos.add("GenQA/h2dGenKStarxy_Transport", "hGenKStarxy_Transport", kTH2D, {axisXY, axisXY}); - histos.add("GenQA/hGenKStarRadius_Generator", "hGenKStarRadius_Generator", kTH1D, {axisRadius}); - histos.add("GenQA/hGenKStarRadius_Transport", "hGenKStarRadius_Transport", kTH1D, {axisRadius}); + histos.add("GenQA/h2dGenKStarxy_Generator", "hGenKStarxy_Generator", kTH2D, {axisConfig.axisXY, axisConfig.axisXY}); + histos.add("GenQA/h2dGenKStarxy_Transport", "hGenKStarxy_Transport", kTH2D, {axisConfig.axisXY, axisConfig.axisXY}); + histos.add("GenQA/hGenKStarRadius_Generator", "hGenKStarRadius_Generator", kTH1D, {axisConfig.axisRadius}); + histos.add("GenQA/hGenKStarRadius_Transport", "hGenKStarRadius_Transport", kTH1D, {axisConfig.axisRadius}); histos.add("GenQA/h2dKStarMCSourceVsPDGMother", "h2dKStarMCSourceVsPDGMother", kTHnSparseD, {{2, -0.5f, 1.5f}, {10001, -5000.5f, +5000.5f}}); histos.add("GenQA/h2dKStarNDaughtersVsPDG", "h2dKStarNDaughtersVsPDG", kTHnSparseD, {{10, -0.5f, +9.5f}, {10001, -5000.5f, +5000.5f}}); @@ -712,72 +716,72 @@ struct sigma0builder { if (doprocessV0QA || doprocessV0MCQA) { // Event selection: - histos.add("V0QA/hEventCentrality", "hEventCentrality", kTH1D, {axisCentrality}); + histos.add("V0QA/hEventCentrality", "hEventCentrality", kTH1D, {axisConfig.axisCentrality}); // Photon part: - histos.add("V0QA/h3dPhotonMass", "h3dPhotonMass", kTH3D, {axisCentrality, axisPt, axisPhotonMass}); - histos.add("V0QA/h3dYPhotonMass", "h3dYPhotonMass", kTH3D, {axisRapidity, axisPt, axisPhotonMass}); - histos.add("V0QA/h3dYPhotonRadius", "h3dYPhotonRadius", kTH3D, {axisRapidity, axisPt, axisRadius}); + histos.add("V0QA/h3dPhotonMass", "h3dPhotonMass", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisPhotonMass}); + histos.add("V0QA/h3dYPhotonMass", "h3dYPhotonMass", kTH3D, {axisConfig.axisRapidity, axisConfig.axisPt, axisConfig.axisPhotonMass}); + histos.add("V0QA/h3dYPhotonRadius", "h3dYPhotonRadius", kTH3D, {axisConfig.axisRapidity, axisConfig.axisPt, axisConfig.axisRadius}); - histos.add("V0QA/h3dTruePhotonMass", "h3dTruePhotonMass", kTH3D, {axisCentrality, axisPt, axisPhotonMass}); - histos.add("V0QA/h2dTrueSigma0PhotonMass", "h2dTrueSigma0PhotonMass", kTH2D, {axisPt, axisPhotonMass}); - histos.add("V0QA/h2dTrueKStarPhotonMass", "h2dTrueKStarPhotonMass", kTH2D, {axisPt, axisPhotonMass}); + histos.add("V0QA/h3dTruePhotonMass", "h3dTruePhotonMass", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisPhotonMass}); + histos.add("V0QA/h2dTrueSigma0PhotonMass", "h2dTrueSigma0PhotonMass", kTH2D, {axisConfig.axisPt, axisConfig.axisPhotonMass}); + histos.add("V0QA/h2dTrueKStarPhotonMass", "h2dTrueKStarPhotonMass", kTH2D, {axisConfig.axisPt, axisConfig.axisPhotonMass}); // Lambda part: - histos.add("V0QA/h3dLambdaMass", "h3dLambdaMass", kTH3D, {axisCentrality, axisPt, axisLambdaMass}); - histos.add("V0QA/h3dTrueLambdaMass", "h3dTrueLambdaMass", kTH3D, {axisCentrality, axisPt, axisLambdaMass}); - histos.add("V0QA/h3dYLambdaMass", "h3dYLambdaMass", kTH3D, {axisRapidity, axisPt, axisLambdaMass}); - histos.add("V0QA/h3dYRLambdaMass", "h3dYRLambdaMass", kTH3D, {axisRapidity, axisRadius, axisLambdaMass}); + histos.add("V0QA/h3dLambdaMass", "h3dLambdaMass", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisLambdaMass}); + histos.add("V0QA/h3dTrueLambdaMass", "h3dTrueLambdaMass", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisLambdaMass}); + histos.add("V0QA/h3dYLambdaMass", "h3dYLambdaMass", kTH3D, {axisConfig.axisRapidity, axisConfig.axisPt, axisConfig.axisLambdaMass}); + histos.add("V0QA/h3dYRLambdaMass", "h3dYRLambdaMass", kTH3D, {axisConfig.axisRapidity, axisConfig.axisRadius, axisConfig.axisLambdaMass}); - histos.add("V0QA/h2dTrueSigma0LambdaMass", "h2dTrueSigma0LambdaMass", kTH2D, {axisPt, axisLambdaMass}); + histos.add("V0QA/h2dTrueSigma0LambdaMass", "h2dTrueSigma0LambdaMass", kTH2D, {axisConfig.axisPt, axisConfig.axisLambdaMass}); // AntiLambda part: - histos.add("V0QA/h3dALambdaMass", "h3dALambdaMass", kTH3D, {axisCentrality, axisPt, axisLambdaMass}); - histos.add("V0QA/h3dTrueALambdaMass", "h3dTrueALambdaMass", kTH3D, {axisCentrality, axisPt, axisLambdaMass}); - histos.add("V0QA/h3dYALambdaMass", "h3dYALambdaMass", kTH3D, {axisRapidity, axisPt, axisLambdaMass}); - histos.add("V0QA/h3dYRALambdaMass", "h3dYRALambdaMass", kTH3D, {axisRapidity, axisRadius, axisLambdaMass}); + histos.add("V0QA/h3dALambdaMass", "h3dALambdaMass", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisLambdaMass}); + histos.add("V0QA/h3dTrueALambdaMass", "h3dTrueALambdaMass", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisLambdaMass}); + histos.add("V0QA/h3dYALambdaMass", "h3dYALambdaMass", kTH3D, {axisConfig.axisRapidity, axisConfig.axisPt, axisConfig.axisLambdaMass}); + histos.add("V0QA/h3dYRALambdaMass", "h3dYRALambdaMass", kTH3D, {axisConfig.axisRapidity, axisConfig.axisRadius, axisConfig.axisLambdaMass}); - histos.add("V0QA/h2dTrueASigma0ALambdaMass", "h2dTrueASigma0ALambdaMass", kTH2D, {axisPt, axisLambdaMass}); + histos.add("V0QA/h2dTrueASigma0ALambdaMass", "h2dTrueASigma0ALambdaMass", kTH2D, {axisConfig.axisPt, axisConfig.axisLambdaMass}); // KShort part: - histos.add("V0QA/h3dKShortMass", "h3dKShortMass", kTH3D, {axisCentrality, axisPt, axisK0SMass}); - histos.add("V0QA/h3dTrueKShortMass", "h3dTrueKShortMass", kTH3D, {axisCentrality, axisPt, axisK0SMass}); - histos.add("V0QA/h3dYKShortMass", "h3dYKShortMass", kTH3D, {axisRapidity, axisPt, axisK0SMass}); - histos.add("V0QA/h3dYRKShortMass", "h3dYRKShortMass", kTH3D, {axisRapidity, axisRadius, axisK0SMass}); - histos.add("V0QA/h2dTrueKStarKShortMass", "h2dTrueKStarKShortMass", kTH2D, {axisPt, axisK0SMass}); + histos.add("V0QA/h3dKShortMass", "h3dKShortMass", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisK0SMass}); + histos.add("V0QA/h3dTrueKShortMass", "h3dTrueKShortMass", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisK0SMass}); + histos.add("V0QA/h3dYKShortMass", "h3dYKShortMass", kTH3D, {axisConfig.axisRapidity, axisConfig.axisPt, axisConfig.axisK0SMass}); + histos.add("V0QA/h3dYRKShortMass", "h3dYRKShortMass", kTH3D, {axisConfig.axisRapidity, axisConfig.axisRadius, axisConfig.axisK0SMass}); + histos.add("V0QA/h2dTrueKStarKShortMass", "h2dTrueKStarKShortMass", kTH2D, {axisConfig.axisPt, axisConfig.axisK0SMass}); } if (doprocessV0Generated) { - histos.add("V0QA/hGenEvents", "hGenEvents", kTH2D, {{axisNch}, {2, -0.5f, +1.5f}}); + histos.add("V0QA/hGenEvents", "hGenEvents", kTH2D, {{axisConfig.axisNch}, {2, -0.5f, +1.5f}}); histos.get(HIST("V0QA/hGenEvents"))->GetYaxis()->SetBinLabel(1, "All gen. events"); histos.get(HIST("V0QA/hGenEvents"))->GetYaxis()->SetBinLabel(2, "Gen. with at least 1 rec. events"); histos.add("V0QA/hGenEventCentrality", "hGenEventCentrality", kTH1D, {{101, 0.0f, 101.0f}}); - histos.add("V0QA/hCentralityVsNcoll_beforeEvSel", "hCentralityVsNcoll_beforeEvSel", kTH2D, {axisCentrality, {50, -0.5f, 49.5f}}); - histos.add("V0QA/hCentralityVsNcoll_afterEvSel", "hCentralityVsNcoll_afterEvSel", kTH2D, {axisCentrality, {50, -0.5f, 49.5f}}); + histos.add("V0QA/hCentralityVsNcoll_beforeEvSel", "hCentralityVsNcoll_beforeEvSel", kTH2D, {axisConfig.axisCentrality, {50, -0.5f, 49.5f}}); + histos.add("V0QA/hCentralityVsNcoll_afterEvSel", "hCentralityVsNcoll_afterEvSel", kTH2D, {axisConfig.axisCentrality, {50, -0.5f, 49.5f}}); - histos.add("V0QA/hCentralityVsMultMC", "hCentralityVsMultMC", kTH2D, {{101, 0.0f, 101.0f}, axisNch}); + histos.add("V0QA/hCentralityVsMultMC", "hCentralityVsMultMC", kTH2D, {{101, 0.0f, 101.0f}, axisConfig.axisNch}); histos.add("V0QA/hEventPVzMC", "hEventPVzMC", kTH1D, {{100, -20.0f, +20.0f}}); histos.add("V0QA/hCentralityVsPVzMC", "hCentralityVsPVzMC", kTH2D, {{101, 0.0f, 101.0f}, {100, -20.0f, +20.0f}}); - histos.add("V0QA/h2dGenPhoton", "h2dGenPhoton", kTH2D, {axisCentrality, axisPt}); - histos.add("V0QA/h2dGenLambda", "h2dGenLambda", kTH2D, {axisCentrality, axisPt}); - histos.add("V0QA/h2dGenAntiLambda", "h2dGenAntiLambda", kTH2D, {axisCentrality, axisPt}); + histos.add("V0QA/h2dGenPhoton", "h2dGenPhoton", kTH2D, {axisConfig.axisCentrality, axisConfig.axisPt}); + histos.add("V0QA/h2dGenLambda", "h2dGenLambda", kTH2D, {axisConfig.axisCentrality, axisConfig.axisPt}); + histos.add("V0QA/h2dGenAntiLambda", "h2dGenAntiLambda", kTH2D, {axisConfig.axisCentrality, axisConfig.axisPt}); - histos.add("V0QA/h2dGenPhotonVsMultMC_RecoedEvt", "h2dGenPhotonVsMultMC_RecoedEvt", kTH2D, {axisNch, axisPt}); - histos.add("V0QA/h2dGenLambdaVsMultMC_RecoedEvt", "h2dGenLambdaVsMultMC_RecoedEvt", kTH2D, {axisNch, axisPt}); - histos.add("V0QA/h2dGenAntiLambdaVsMultMC_RecoedEvt", "h2dGenAntiLambdaVsMultMC_RecoedEvt", kTH2D, {axisNch, axisPt}); + histos.add("V0QA/h2dGenPhotonVsMultMC_RecoedEvt", "h2dGenPhotonVsMultMC_RecoedEvt", kTH2D, {axisConfig.axisNch, axisConfig.axisPt}); + histos.add("V0QA/h2dGenLambdaVsMultMC_RecoedEvt", "h2dGenLambdaVsMultMC_RecoedEvt", kTH2D, {axisConfig.axisNch, axisConfig.axisPt}); + histos.add("V0QA/h2dGenAntiLambdaVsMultMC_RecoedEvt", "h2dGenAntiLambdaVsMultMC_RecoedEvt", kTH2D, {axisConfig.axisNch, axisConfig.axisPt}); - histos.add("V0QA/h2dGenPhotonVsMultMC", "h2dGenPhotonVsMultMC", kTH2D, {axisNch, axisPt}); - histos.add("V0QA/h2dGenLambdaVsMultMC", "h2dGenLambdaVsMultMC", kTH2D, {axisNch, axisPt}); - histos.add("V0QA/h2dGenAntiLambdaVsMultMC", "h2dGenAntiLambdaVsMultMC", kTH2D, {axisNch, axisPt}); + histos.add("V0QA/h2dGenPhotonVsMultMC", "h2dGenPhotonVsMultMC", kTH2D, {axisConfig.axisNch, axisConfig.axisPt}); + histos.add("V0QA/h2dGenLambdaVsMultMC", "h2dGenLambdaVsMultMC", kTH2D, {axisConfig.axisNch, axisConfig.axisPt}); + histos.add("V0QA/h2dGenAntiLambdaVsMultMC", "h2dGenAntiLambdaVsMultMC", kTH2D, {axisConfig.axisNch, axisConfig.axisPt}); - histos.add("V0QA/h2dGenKShort", "h2dGenKShort", kTH2D, {axisCentrality, axisPt}); + histos.add("V0QA/h2dGenKShort", "h2dGenKShort", kTH2D, {axisConfig.axisCentrality, axisConfig.axisPt}); - histos.add("V0QA/h2dGenKShortVsMultMC_RecoedEvt", "h2dGenKShortVsMultMC_RecoedEvt", kTH2D, {axisNch, axisPt}); + histos.add("V0QA/h2dGenKShortVsMultMC_RecoedEvt", "h2dGenKShortVsMultMC_RecoedEvt", kTH2D, {axisConfig.axisNch, axisConfig.axisPt}); - histos.add("V0QA/h2dGenKShortVsMultMC", "h2dGenKShortVsMultMC", kTH2D, {axisNch, axisPt}); + histos.add("V0QA/h2dGenKShortVsMultMC", "h2dGenKShortVsMultMC", kTH2D, {axisConfig.axisNch, axisConfig.axisPt}); } // inspect histogram sizes, please @@ -1466,7 +1470,7 @@ struct sigma0builder { else if (std::abs(v0MC.pdgCode()) == PDG_t::kLambda0) ymc = v0MC.rapidityMC(1); else if (v0MC.pdgCode() == PDG_t::kK0Short) - ymc = v0MC.rapidityMC(2); // what is the 2 here? + ymc = v0MC.rapidityMC(0); // 0 = K0 mass hypothesis (1/2 = Lambda); see LFStrangenessTables.h:829 if ((ymc < genSelections.mc_rapidityMin) || (ymc > genSelections.mc_rapidityMax)) continue; diff --git a/PWGLF/Tasks/Resonances/CMakeLists.txt b/PWGLF/Tasks/Resonances/CMakeLists.txt index 74c48c0872a..63d99f1ddfe 100644 --- a/PWGLF/Tasks/Resonances/CMakeLists.txt +++ b/PWGLF/Tasks/Resonances/CMakeLists.txt @@ -309,6 +309,11 @@ o2physics_add_dpl_workflow(k892hadronphoton PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::AnalysisCCDB COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(k892hadronphotonbkg + SOURCES K892hadronphotonBkg.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::AnalysisCCDB + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(chk892li SOURCES chk892LI.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore diff --git a/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx new file mode 100644 index 00000000000..e8c2ed111a3 --- /dev/null +++ b/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx @@ -0,0 +1,767 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +// +// This is a ask that computes the same-event rotational and the +// mixed-event combinatorial backgrounds for the K*(892) -> K0S + gamma analysis. +// *+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* +// K892 hadron-photon background task +// *+-+*+-+*+-+*+-+*+-+*+-+*+-+*+-+* +// +// Comments, questions, complaints, suggestions? +// Please write to: +// oussama.benchikhi@cern.ch +// + +#include "PWGLF/DataModel/LFSigmaTables.h" +#include "PWGLF/DataModel/LFStrangenessMLTables.h" +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/CCDB/EventSelectionParams.h" +#include "Common/CCDB/ctpRateFetcher.h" +#include "Common/Core/RecoDecay.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using std::array; +using dauTracks = soa::Join; +using V0StandardDerivedDatas = soa::Join; + +struct k892hadronphotonBkg { + Service ccdb; + ctpRateFetcher rateFetcher; + TRandom3 rotRng{12345}; // struct member; fixed seed for reproducibility across grid jobs + + // Histogram registry + HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + + Configurable doPPAnalysis{"doPPAnalysis", true, "if in pp, set to true"}; + + // For ML Selection + Configurable useMLScores{"useMLScores", false, "use ML scores to select candidates"}; + + // Interaction-rate retrieval (used by the event selection) + Configurable fGetIR{"fGetIR", false, "Flag to retrieve the IR info."}; + Configurable fIRCrashOnNull{"fIRCrashOnNull", false, "Flag to avoid CTP RateFetcher crash."}; + Configurable irSource{"irSource", "T0VTX", "Estimator of the interaction rate (Recommended: pp --> T0VTX, Pb-Pb --> ZNC hadronic)"}; + + struct : ConfigurableGroup { + std::string prefix = "kstarBkgConfig"; + Configurable doSameEvtRotation{"doSameEvtRotation", false, "Same-event rotational background"}; + Configurable doEvtMixing{"doEvtMixing", false, "Mixed-event background"}; + Configurable nMix{"nMix", 5, "Number of mixed events"}; + Configurable deltaCollision{"deltaCollision", 25, "Min |Δ globalIndex| for mixing"}; + Configurable KStarMaxOPAngle{"KStarMaxOPAngle", 7.f, "Max opening angle (rad)"}; + Configurable KStarMaxRap{"KStarMaxRap", 0.5f, "Max |y(K*)|"}; + Configurable nBkgRot{"nBkgRot", 3, "Rotations per pair (rotational bkg)"}; + Configurable rotationalCut{"rotationalCut", 10, "theta band: [pi - pi/cut, pi + pi/cut]"}; + } kstarBkgConfig; + + ConfigurableAxis axisVertexMixBkg{"axisVertexMixBkg", {VARIABLE_WIDTH, -10.f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "z-vertex bins for mixing"}; + ConfigurableAxis axisCentralityMixBkg{"axisCentralityMixBkg", {VARIABLE_WIDTH, 0.0f, 1.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f, 110.0f}, "centrality bins for mixing"}; + + struct : ConfigurableGroup { + std::string prefix = "eventSelections"; // JSON group name + Configurable fUseEventSelection{"fUseEventSelection", false, "Apply event selection cuts"}; + Configurable requireSel8{"requireSel8", true, "require sel8 event selection"}; + Configurable requireTriggerTVX{"requireTriggerTVX", true, "require FT0 vertex (acceptable FT0C-FT0A time difference) at trigger level"}; + Configurable rejectITSROFBorder{"rejectITSROFBorder", true, "reject events at ITS ROF border"}; + Configurable rejectTFBorder{"rejectTFBorder", true, "reject events at TF border"}; + Configurable requireIsVertexITSTPC{"requireIsVertexITSTPC", true, "require events with at least one ITS-TPC track"}; + Configurable requireIsGoodZvtxFT0VsPV{"requireIsGoodZvtxFT0VsPV", true, "require events with PV position along z consistent (within 1 cm) between PV reconstructed using tracks and PV using FT0 A-C time difference"}; + Configurable requireIsVertexTOFmatched{"requireIsVertexTOFmatched", false, "require events with at least one of vertex contributors matched to TOF"}; + Configurable requireIsVertexTRDmatched{"requireIsVertexTRDmatched", false, "require events with at least one of vertex contributors matched to TRD"}; + Configurable rejectSameBunchPileup{"rejectSameBunchPileup", false, "reject collisions in case of pileup with another collision in the same foundBC"}; + Configurable requireNoCollInTimeRangeStd{"requireNoCollInTimeRangeStd", false, "reject collisions corrupted by the cannibalism, with other collisions within +/- 2 microseconds or mult above a certain threshold in -4 - -2 microseconds"}; + Configurable requireNoCollInTimeRangeStrict{"requireNoCollInTimeRangeStrict", false, "reject collisions corrupted by the cannibalism, with other collisions within +/- 10 microseconds"}; + Configurable requireNoCollInTimeRangeNarrow{"requireNoCollInTimeRangeNarrow", false, "reject collisions corrupted by the cannibalism, with other collisions within +/- 2 microseconds"}; + Configurable requireNoCollInROFStd{"requireNoCollInROFStd", false, "reject collisions corrupted by the cannibalism, with other collisions within the same ITS ROF with mult. above a certain threshold"}; + Configurable requireNoCollInROFStrict{"requireNoCollInROFStrict", false, "reject collisions corrupted by the cannibalism, with other collisions within the same ITS ROF"}; + Configurable requireINEL0{"requireINEL0", true, "require INEL>0 event selection"}; + Configurable requireINEL1{"requireINEL1", false, "require INEL>1 event selection"}; + Configurable maxZVtxPosition{"maxZVtxPosition", 10., "max Z vtx position"}; + Configurable useFT0CbasedOccupancy{"useFT0CbasedOccupancy", false, "Use sum of FT0-C amplitudes for estimating occupancy? (if not, use track-based definition)"}; + // fast check on occupancy + Configurable minOccupancy{"minOccupancy", -1, "minimum occupancy from neighbouring collisions"}; + Configurable maxOccupancy{"maxOccupancy", -1, "maximum occupancy from neighbouring collisions"}; + // fast check on interaction rate + Configurable minIR{"minIR", -1, "minimum IR collisions"}; + Configurable maxIR{"maxIR", -1, "maximum IR collisions"}; + } eventSelections; + + //// Photon criteria: + struct : ConfigurableGroup { + std::string prefix = "photonSelections"; // JSON group name + Configurable Gamma_MLThreshold{"Gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas"}; + Configurable Photonv0TypeSel{"Photonv0TypeSel", 7, "select on a certain V0 type (leave negative if no selection desired)"}; + Configurable PhotonMinDCADauToPv{"PhotonMinDCADauToPv", 0.0, "Min DCA daughter To PV (cm)"}; + Configurable PhotonMaxDCAV0Dau{"PhotonMaxDCAV0Dau", 3.5, "Max DCA V0 Daughters (cm)"}; + Configurable PhotonMinTPCCrossedRows{"PhotonMinTPCCrossedRows", 30, "Min daughter TPC Crossed Rows"}; + Configurable PhotonMinTPCNSigmas{"PhotonMinTPCNSigmas", -7, "Min TPC NSigmas for daughters"}; + Configurable PhotonMaxTPCNSigmas{"PhotonMaxTPCNSigmas", 7, "Max TPC NSigmas for daughters"}; + Configurable PhotonMinRapidity{"PhotonMinRapidity", -0.5, "v0 min rapidity"}; + Configurable PhotonMaxRapidity{"PhotonMaxRapidity", 0.5, "v0 max rapidity"}; + Configurable PhotonDauEtaMin{"PhotonDauEtaMin", -0.8, "Min pseudorapidity of daughter tracks"}; + Configurable PhotonDauEtaMax{"PhotonDauEtaMax", 0.8, "Max pseudorapidity of daughter tracks"}; + Configurable PhotonMinRadius{"PhotonMinRadius", 3.0, "Min photon conversion radius (cm)"}; + Configurable PhotonMaxRadius{"PhotonMaxRadius", 115, "Max photon conversion radius (cm)"}; + Configurable PhotonMinZ{"PhotonMinZ", -240, "Min photon conversion point z value (cm)"}; + Configurable PhotonMaxZ{"PhotonMaxZ", 240, "Max photon conversion point z value (cm)"}; + Configurable PhotonMaxQt{"PhotonMaxQt", 0.08, "Max photon qt value (AP plot) (GeV/c)"}; + Configurable PhotonMaxAlpha{"PhotonMaxAlpha", 1.0, "Max photon alpha absolute value (AP plot)"}; + Configurable PhotonMinV0cospa{"PhotonMinV0cospa", 0.80, "Min V0 CosPA"}; + Configurable PhotonMaxMass{"PhotonMaxMass", 0.10, "Max photon mass (GeV/c^{2})"}; + Configurable PhotonPhiMin1{"PhotonPhiMin1", -1, "Phi min value to reject photons, region 1 (leave negative if no selection desired)"}; + Configurable PhotonPhiMax1{"PhotonPhiMax1", -1, "Phi max value to reject photons, region 1 (leave negative if no selection desired)"}; + Configurable PhotonPhiMin2{"PhotonPhiMin2", -1, "Phi max value to reject photons, region 2 (leave negative if no selection desired)"}; + Configurable PhotonPhiMax2{"PhotonPhiMax2", -1, "Phi min value to reject photons, region 2 (leave negative if no selection desired)"}; + } photonSelections; + + // KShort criteria: + struct : ConfigurableGroup { + std::string prefix = "kshortSelections"; // JSON group name + Configurable KShort_MLThreshold{"KShort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; + Configurable KShortMinDCANegToPv{"KShortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; + Configurable KShortMinDCAPosToPv{"KShortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; + Configurable KShortMaxDCAV0Dau{"KShortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; + Configurable KShortMinv0radius{"KShortMinv0radius", 0.0, "Min V0 radius (cm)"}; + Configurable KShortMaxv0radius{"KShortMaxv0radius", 40, "Max V0 radius (cm)"}; + Configurable KShortMinv0cospa{"KShortMinv0cospa", 0.95, "Min V0 CosPA"}; + Configurable KShortMaxLifeTime{"KShortMaxLifeTime", 20, "Max lifetime"}; + Configurable KShortWindow{"KShortWindow", 0.015, "Mass window around expected (in GeV/c2). Leave negative to disable"}; + Configurable KShortMinRapidity{"KShortMinRapidity", -0.5, "v0 min rapidity"}; + Configurable KShortMaxRapidity{"KShortMaxRapidity", 0.5, "v0 max rapidity"}; + Configurable KShortDauEtaMin{"KShortDauEtaMin", -0.8, "Min pseudorapidity of daughter tracks"}; + Configurable KShortDauEtaMax{"KShortDauEtaMax", 0.8, "Max pseudorapidity of daughter tracks"}; + Configurable KShortMinZ{"KShortMinZ", -240, "Min kshort decay point z value (cm)"}; + Configurable KShortMaxZ{"KShortMaxZ", 240, "Max kshort decay point z value (cm)"}; + Configurable KShortMinTPCCrossedRows{"KShortMinTPCCrossedRows", 50, "Min daughter TPC Crossed Rows"}; + Configurable KShortMinITSclusters{"KShortMinITSclusters", 1, "minimum ITS clusters"}; + Configurable KShortRejectPosITSafterburner{"KShortRejectPosITSafterburner", false, "reject positive track formed out of afterburner ITS tracks"}; + Configurable KShortRejectNegITSafterburner{"KShortRejectNegITSafterburner", false, "reject negative track formed out of afterburner ITS tracks"}; + Configurable KShortArmenterosCoefficient{"KShortArmenterosCoefficient", 0.2, "Armenteros-Podolanski coefficient to reject lambdas"}; + } kshortSelections; + + struct : ConfigurableGroup { + // base properties + std::string prefix = "axisConfig"; // JSON group name + ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 30.0f, 35.0f, 40.0f, 50.0f}, "pt axis for analysis"}; + ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f, 110.0f}, "Centrality"}; + ConfigurableAxis axisKStarMass{"axisKStarMass", {500, 0.6f, 1.6f}, "M_{K^{*}} (GeV/c^{2})"}; + ConfigurableAxis axisIRBinning{"axisIRBinning", {151, -10, 1500}, "Binning for the interaction rate (kHz)"}; + } axisConfig; + + void init(InitContext const&) + { + // setting CCDB service + ccdb->setURL("http://alice-ccdb.cern.ch"); + ccdb->setCaching(true); + ccdb->setFatalWhenNull(false); + + histos.add("hEventCentrality", "hEventCentrality", kTH1D, {axisConfig.axisCentrality}); + + if (eventSelections.fUseEventSelection) { + histos.add("hEventSelection", "hEventSelection", kTH1D, {{21, -0.5f, +20.5f}}); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(1, "All collisions"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(2, "sel8 cut"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(3, "kIsTriggerTVX"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(4, "kNoITSROFrameBorder"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(5, "kNoTimeFrameBorder"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(6, "posZ cut"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(7, "kIsVertexITSTPC"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(8, "kIsGoodZvtxFT0vsPV"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(9, "kIsVertexTOFmatched"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(10, "kIsVertexTRDmatched"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(11, "kNoSameBunchPileup"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(12, "kNoCollInTimeRangeStd"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(13, "kNoCollInTimeRangeStrict"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(14, "kNoCollInTimeRangeNarrow"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(15, "kNoCollInRofStd"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(16, "kNoCollInRofStrict"); + if (doPPAnalysis) { + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(17, "INEL>0"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(18, "INEL>1"); + } else { + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(17, "Below min occup."); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(18, "Above max occup."); + } + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(19, "Below min IR"); + histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(20, "Above max IR"); + + if (fGetIR) { + histos.add("GeneralQA/hRunNumberNegativeIR", "", kTH1D, {{1, 0., 1.}}); + histos.add("GeneralQA/hInteractionRate", "hInteractionRate", kTH1D, {axisConfig.axisIRBinning}); + histos.add("GeneralQA/hCentralityVsInteractionRate", "hCentralityVsInteractionRate", kTH2D, {axisConfig.axisCentrality, axisConfig.axisIRBinning}); + } + } + + if (kstarBkgConfig.doSameEvtRotation || kstarBkgConfig.doEvtMixing) { + histos.add("KStarBkg/hDeltaCollision", "hDeltaCollision", kTH1D, {{2000, -1000.f, 1000.f}}); + histos.add("KStarBkg/h2dCentralityCollPair", "h2dCentralityCollPair", kTH2D, {axisConfig.axisCentrality, axisConfig.axisCentrality}); + } + if (kstarBkgConfig.doSameEvtRotation) { + histos.add("KStarBkg/h2dRotKStarMassVsPt", "h2dRotKStarMassVsPt", kTH2D, {axisConfig.axisKStarMass, axisConfig.axisPt}); + histos.add("KStarBkg/h3dRotKStarMassVsPt", "h3dRotKStarMassVsPt", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisKStarMass}); + histos.add("KStarBkg/h3dRotKStarPtVsOPAngle", "h3dRotKStarPtVsOPAngle", kTH3D, {{140, 0.f, 7.f}, axisConfig.axisPt, axisConfig.axisKStarMass}); + } + if (kstarBkgConfig.doEvtMixing) { + histos.add("KStarBkg/h2dMixedKStarMassVsPt", "h2dMixedKStarMassVsPt", kTH2D, {axisConfig.axisKStarMass, axisConfig.axisPt}); + histos.add("KStarBkg/h3dMixedKStarMassVsPt", "h3dMixedKStarMassVsPt", kTH3D, {axisConfig.axisCentrality, axisConfig.axisPt, axisConfig.axisKStarMass}); + histos.add("KStarBkg/h3dMixedKStarPtVsOPAngle", "h3dMixedKStarPtVsOPAngle", kTH3D, {{140, 0.f, 7.f}, axisConfig.axisPt, axisConfig.axisKStarMass}); + } + } + + //_______________________________________________ + // Event selection (identical to the builder) + template + bool IsEventAccepted(TCollision const& collision, bool fillHists) + { + if (fillHists) + histos.fill(HIST("hEventSelection"), 0. /* all collisions */); + if (eventSelections.requireSel8 && !collision.sel8()) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 1 /* sel8 collisions */); + if (eventSelections.requireTriggerTVX && !collision.selection_bit(aod::evsel::kIsTriggerTVX)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 2 /* FT0 vertex (acceptable FT0C-FT0A time difference) collisions */); + if (eventSelections.rejectITSROFBorder && !collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 3 /* Not at ITS ROF border */); + if (eventSelections.rejectTFBorder && !collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 4 /* Not at TF border */); + if (std::abs(collision.posZ()) > eventSelections.maxZVtxPosition) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 5 /* vertex-Z selected */); + if (eventSelections.requireIsVertexITSTPC && !collision.selection_bit(o2::aod::evsel::kIsVertexITSTPC)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 6 /* Contains at least one ITS-TPC track */); + if (eventSelections.requireIsGoodZvtxFT0VsPV && !collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 7 /* PV position consistency check */); + if (eventSelections.requireIsVertexTOFmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTOFmatched)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 8 /* PV with at least one contributor matched with TOF */); + if (eventSelections.requireIsVertexTRDmatched && !collision.selection_bit(o2::aod::evsel::kIsVertexTRDmatched)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 9 /* PV with at least one contributor matched with TRD */); + if (eventSelections.rejectSameBunchPileup && !collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 10 /* Not at same bunch pile-up */); + if (eventSelections.requireNoCollInTimeRangeStd && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 11 /* No other collision within +/- 2 microseconds or mult above a certain threshold in -4 - -2 microseconds*/); + if (eventSelections.requireNoCollInTimeRangeStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStrict)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 12 /* No other collision within +/- 10 microseconds */); + if (eventSelections.requireNoCollInTimeRangeNarrow && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeNarrow)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 13 /* No other collision within +/- 2 microseconds */); + if (eventSelections.requireNoCollInROFStd && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStandard)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 14 /* No other collision within the same ITS ROF with mult. above a certain threshold */); + if (eventSelections.requireNoCollInROFStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStrict)) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 15 /* No other collision within the same ITS ROF */); + if (doPPAnalysis) { // we are in pp + if (eventSelections.requireINEL0 && collision.multNTracksPVeta1() < 1) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 16 /* INEL > 0 */); + if (eventSelections.requireINEL1 && collision.multNTracksPVeta1() < 2) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 17 /* INEL > 1 */); + } else { // we are in Pb-Pb + float collisionOccupancy = eventSelections.useFT0CbasedOccupancy ? collision.ft0cOccupancyInTimeRange() : collision.trackOccupancyInTimeRange(); + if (eventSelections.minOccupancy >= 0 && collisionOccupancy < eventSelections.minOccupancy) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 16 /* Below min occupancy */); + if (eventSelections.maxOccupancy >= 0 && collisionOccupancy > eventSelections.maxOccupancy) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 17 /* Above max occupancy */); + } + + // Fetch interaction rate only if required (in order to limit ccdb calls) + float interactionRate = (fGetIR) ? rateFetcher.fetch(ccdb.service, collision.timestamp(), collision.runNumber(), irSource, fIRCrashOnNull) * 1.e-3 : -1; + float centrality = doPPAnalysis ? collision.centFT0M() : collision.centFT0C(); + + if (fGetIR) { + if (interactionRate < 0) + histos.get(HIST("GeneralQA/hRunNumberNegativeIR"))->Fill(Form("%d", collision.runNumber()), 1); // This lists all run numbers without IR info! + + histos.fill(HIST("GeneralQA/hInteractionRate"), interactionRate); + histos.fill(HIST("GeneralQA/hCentralityVsInteractionRate"), centrality, interactionRate); + } + + if (eventSelections.minIR >= 0 && interactionRate < eventSelections.minIR) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 18 /* Below min IR */); + + if (eventSelections.maxIR >= 0 && interactionRate > eventSelections.maxIR) { + return false; + } + if (fillHists) + histos.fill(HIST("hEventSelection"), 19 /* Above max IR */); + + // Fill centrality histogram after event selection + if (fillHists) + histos.fill(HIST("hEventCentrality"), centrality); + + return true; + } + + //_______________________________________________ + // Process v0 photon candidate (data only, no QA fills) + template + bool processPhotonCandidate(TV0Object const& gamma) + { + // V0 type selection + if (gamma.v0Type() != photonSelections.Photonv0TypeSel && photonSelections.Photonv0TypeSel > -1) + return false; + + float PhotonY = RecoDecay::y(std::array{gamma.px(), gamma.py(), gamma.pz()}, o2::constants::physics::MassGamma); + + if (useMLScores) { + if (gamma.gammaBDTScore() <= photonSelections.Gamma_MLThreshold) + return false; + + } else { + // Standard selection + // Gamma basic selection criteria: + if ((gamma.mGamma() < 0) || (gamma.mGamma() > photonSelections.PhotonMaxMass)) + return false; + + if ((PhotonY < photonSelections.PhotonMinRapidity) || (PhotonY > photonSelections.PhotonMaxRapidity)) + return false; + + if (gamma.negativeeta() < photonSelections.PhotonDauEtaMin || gamma.negativeeta() > photonSelections.PhotonDauEtaMax) + return false; + + if (gamma.positiveeta() < photonSelections.PhotonDauEtaMin || gamma.positiveeta() > photonSelections.PhotonDauEtaMax) + return false; + + if ((TMath::Abs(gamma.dcapostopv()) < photonSelections.PhotonMinDCADauToPv) || (TMath::Abs(gamma.dcanegtopv()) < photonSelections.PhotonMinDCADauToPv)) + return false; + + if (TMath::Abs(gamma.dcaV0daughters()) > photonSelections.PhotonMaxDCAV0Dau) + return false; + + if ((gamma.v0radius() < photonSelections.PhotonMinRadius) || (gamma.v0radius() > photonSelections.PhotonMaxRadius)) + return false; + + if ((gamma.z() < photonSelections.PhotonMinZ) || (gamma.z() > photonSelections.PhotonMaxZ)) + return false; + + if (gamma.v0cosPA() < photonSelections.PhotonMinV0cospa) + return false; + + float PhotonPhi = RecoDecay::phi(gamma.px(), gamma.py()); + if ((((PhotonPhi > photonSelections.PhotonPhiMin1) && (PhotonPhi < photonSelections.PhotonPhiMax1)) || ((PhotonPhi > photonSelections.PhotonPhiMin2) && (PhotonPhi < photonSelections.PhotonPhiMax2))) && ((photonSelections.PhotonPhiMin1 != -1) && (photonSelections.PhotonPhiMax1 != -1) && (photonSelections.PhotonPhiMin2 != -1) && (photonSelections.PhotonPhiMax2 != -1))) + return false; + + if (gamma.qtarm() > photonSelections.PhotonMaxQt) + return false; + + if (TMath::Abs(gamma.alpha()) > photonSelections.PhotonMaxAlpha) + return false; + + auto posTrackGamma = gamma.template posTrackExtra_as(); + auto negTrackGamma = gamma.template negTrackExtra_as(); + + if ((posTrackGamma.tpcCrossedRows() < photonSelections.PhotonMinTPCCrossedRows) || (negTrackGamma.tpcCrossedRows() < photonSelections.PhotonMinTPCCrossedRows)) + return false; + + if (((posTrackGamma.tpcNSigmaEl() < photonSelections.PhotonMinTPCNSigmas) || (posTrackGamma.tpcNSigmaEl() > photonSelections.PhotonMaxTPCNSigmas))) + return false; + + if (((negTrackGamma.tpcNSigmaEl() < photonSelections.PhotonMinTPCNSigmas) || (negTrackGamma.tpcNSigmaEl() > photonSelections.PhotonMaxTPCNSigmas))) + return false; + } + + return true; + } + + //_______________________________________________ + // Process K0Short candidate (data only, no QA fills) + template + bool processKShortCandidate(TV0Object const& kshort, TCollision const& collision) + { + // V0 type selection + if (kshort.v0Type() != 1) + return false; + + if (useMLScores) { + // if (kshort.k0ShortBDTScore() <= kshortSelections.KShort_MLThreshold) + return false; + + } else { + // KShort basic selection criteria: + if ((TMath::Abs(kshort.mK0Short() - o2::constants::physics::MassK0Short) > kshortSelections.KShortWindow) && kshortSelections.KShortWindow > 0) + return false; + + if ((kshort.yK0Short() < kshortSelections.KShortMinRapidity) || (kshort.yK0Short() > kshortSelections.KShortMaxRapidity)) + return false; + + if ((kshort.negativeeta() < kshortSelections.KShortDauEtaMin) || (kshort.negativeeta() > kshortSelections.KShortDauEtaMax)) + return false; + + if ((kshort.positiveeta() < kshortSelections.KShortDauEtaMin) || (kshort.positiveeta() > kshortSelections.KShortDauEtaMax)) + return false; + + if ((TMath::Abs(kshort.dcapostopv()) < kshortSelections.KShortMinDCAPosToPv) || (TMath::Abs(kshort.dcanegtopv()) < kshortSelections.KShortMinDCANegToPv)) + return false; + + if ((kshort.v0radius() < kshortSelections.KShortMinv0radius) || (kshort.v0radius() > kshortSelections.KShortMaxv0radius)) + return false; + + if ((kshort.z() < kshortSelections.KShortMinZ) || (kshort.z() > kshortSelections.KShortMaxZ)) + return false; + + if (TMath::Abs(kshort.dcaV0daughters()) > kshortSelections.KShortMaxDCAV0Dau) + return false; + + if (kshort.qtarm() < kshortSelections.KShortArmenterosCoefficient * TMath::Abs(kshort.alpha())) + return false; + + if (kshort.v0cosPA() < kshortSelections.KShortMinv0cospa) + return false; + + auto posTrackKShort = kshort.template posTrackExtra_as(); + auto negTrackKShort = kshort.template negTrackExtra_as(); + + if ((posTrackKShort.tpcCrossedRows() < kshortSelections.KShortMinTPCCrossedRows) || (negTrackKShort.tpcCrossedRows() < kshortSelections.KShortMinTPCCrossedRows)) + return false; + + // MinITSCls + bool posIsFromAfterburner = posTrackKShort.itsChi2PerNcl() < 0; + bool negIsFromAfterburner = negTrackKShort.itsChi2PerNcl() < 0; + + if (posTrackKShort.itsNCls() < kshortSelections.KShortMinITSclusters && (!kshortSelections.KShortRejectPosITSafterburner || posIsFromAfterburner)) + return false; + if (negTrackKShort.itsNCls() < kshortSelections.KShortMinITSclusters && (!kshortSelections.KShortRejectNegITSafterburner || negIsFromAfterburner)) + return false; + + float fKShortLifeTime = kshort.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short; + if (fKShortLifeTime > kshortSelections.KShortMaxLifeTime) + return false; + } + return true; + } + + //_______________________________________________ + // Compute same-event rotational background for K* within a single collision + template + void calculateRotBackground(TCollision const& coll, + std::vector const& photonIndices, + std::vector const& kshortIndices, + TV0s const& fullV0s) + { + if (photonIndices.empty() || kshortIndices.empty()) + return; + + const float centrality = doPPAnalysis ? coll.centFT0M() : coll.centFT0C(); + for (int kIdx : kshortIndices) { + auto kshort = fullV0s.rawIteratorAt(kIdx); + + float kPt = kshort.pt(); + float kEta = kshort.eta(); + float kPhi = kshort.phi(); + + for (int pIdx : photonIndices) { + auto photon = fullV0s.rawIteratorAt(pIdx); + + // photon as a massless 4-vector + ROOT::Math::PtEtaPhiMVector pGamma(photon.pt(), + photon.eta(), + photon.phi(), + 0.0); + + for (int irot = 0; irot < kstarBkgConfig.nBkgRot; ++irot) { + float theta = rotRng.Uniform(o2::constants::math::PI - o2::constants::math::PI / kstarBkgConfig.rotationalCut, + o2::constants::math::PI + o2::constants::math::PI / kstarBkgConfig.rotationalCut); + + ROOT::Math::PtEtaPhiMVector kRot(kPt, kEta, kPhi + theta, o2::constants::physics::MassK0Short); + + auto kstar = pGamma + kRot; + + float rapidity = RecoDecay::y(std::array{static_cast(kstar.Px()), + static_cast(kstar.Py()), + static_cast(kstar.Pz())}, + o2::constants::physics::MassK0Star892); + if (std::abs(rapidity) > kstarBkgConfig.KStarMaxRap) + continue; + + // Opening angle between photon and rotated K0s (QA only, not used as a cut) + double cosOA = pGamma.Vect().Dot(kRot.Vect()) / (pGamma.P() * kRot.P()); + double openAngle = std::acos(cosOA); + + histos.fill(HIST("KStarBkg/h2dRotKStarMassVsPt"), kstar.M(), kstar.Pt()); + histos.fill(HIST("KStarBkg/h3dRotKStarMassVsPt"), centrality, kstar.Pt(), kstar.M()); + histos.fill(HIST("KStarBkg/h3dRotKStarPtVsOPAngle"), openAngle, kstar.Pt(), kstar.M()); + } + } + } + } + + //_______________________________________________ + // Centrality helper for the background (keeps the builder's semantics) + template + float getCentralityRun3Bkg(TCollision const& collision) + { + return doPPAnalysis ? collision.centFT0M() : collision.centFT0C(); + } + + //_______________________________________________ + // Main: same-event rotation + event mixing for K* background (data only) + using BkgBinningType = ColumnBinningPolicy; + template + void calculateKStarBkg(TCollisions const& collisions, TV0s const& fullV0s) + { + // Per-collision pools of selected photon and K0s V0 indices + std::vector> photonPool(collisions.size()); + std::vector> kshortPool(collisions.size()); + + // V0 grouping by straCollisionId + std::vector> v0grouped(collisions.size()); + for (const auto& v0 : fullV0s) { + v0grouped[v0.straCollisionId()].push_back(v0.globalIndex()); + } + + // ── Pass 1: populate pools using single-particle selections ── + for (const auto& coll : collisions) { + + if (eventSelections.fUseEventSelection && !IsEventAccepted(coll, true)) + continue; + + for (size_t i = 0; i < v0grouped[coll.globalIndex()].size(); i++) { + auto v0 = fullV0s.rawIteratorAt(v0grouped[coll.globalIndex()][i]); + + if (processPhotonCandidate(v0)) + photonPool[coll.globalIndex()].push_back(v0.globalIndex()); + + if (processKShortCandidate(v0, coll)) + kshortPool[coll.globalIndex()].push_back(v0.globalIndex()); + } + + // Same-event rotational background + if (kstarBkgConfig.doSameEvtRotation) { + calculateRotBackground(coll, + photonPool[coll.globalIndex()], + kshortPool[coll.globalIndex()], + fullV0s); + } + } + + // Event Mixing + if (!kstarBkgConfig.doEvtMixing) + return; + + // Build the mixing binning locally: a struct member initialized from a + // ConfigurableAxis captures the default bins at task construction time (before + // the framework applies JSON overrides), silently ignoring user configuration. + BkgBinningType bkgColBinning{{axisVertexMixBkg, axisCentralityMixBkg}, true}; + + for (auto& [coll1, coll2] : selfCombinations(bkgColBinning, kstarBkgConfig.nMix, -1, + collisions, collisions)) { + if (coll1.globalIndex() == coll2.globalIndex()) + continue; + + histos.fill(HIST("KStarBkg/hDeltaCollision"), + coll1.globalIndex() - coll2.globalIndex()); + histos.fill(HIST("KStarBkg/h2dCentralityCollPair"), + getCentralityRun3Bkg(coll1), getCentralityRun3Bkg(coll2)); + + if (std::abs(int64_t(coll1.globalIndex()) - int64_t(coll2.globalIndex())) < kstarBkgConfig.deltaCollision) + continue; + + auto const& photons1 = photonPool[coll1.globalIndex()]; + auto const& kshorts1 = kshortPool[coll1.globalIndex()]; + auto const& photons2 = photonPool[coll2.globalIndex()]; + auto const& kshorts2 = kshortPool[coll2.globalIndex()]; + + // K0s(coll1) × γ(coll2) + if (!kshorts1.empty() && !photons2.empty()) { + for (int kIdx : kshorts1) { + auto kshort = fullV0s.rawIteratorAt(kIdx); + float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); + ROOT::Math::PxPyPzEVector FourMomKShort( + kshort.px(), kshort.py(), kshort.pz(), + std::sqrt(kP * kP + + o2::constants::physics::MassK0Short * + o2::constants::physics::MassK0Short)); + + for (int pIdx : photons2) { + auto photon = fullV0s.rawIteratorAt(pIdx); + float pP = std::hypot(photon.px(), photon.py(), photon.pz()); + ROOT::Math::PxPyPzEVector FourMomPhoton( + photon.px(), photon.py(), photon.pz(), pP); + + auto FourMomKStar = FourMomPhoton + FourMomKShort; + + double cosOA = FourMomPhoton.Vect().Dot(FourMomKShort.Vect()) / + (FourMomPhoton.P() * FourMomKShort.P()); + double openAngle = std::acos(cosOA); + float mass = FourMomKStar.M(); + float pt = FourMomKStar.Pt(); + // Rapidity computed under the K*(892) mass hypothesis (NOT the actual pair + // invariant mass) to match the same-event rotational background and the + // buildKStar signal selection, so the rapidity acceptance is identical for + // signal and all backgrounds. + float rapidity = RecoDecay::y(std::array{static_cast(FourMomKStar.Px()), + static_cast(FourMomKStar.Py()), + static_cast(FourMomKStar.Pz())}, + o2::constants::physics::MassK0Star892); + + if (openAngle > kstarBkgConfig.KStarMaxOPAngle) + continue; + if (std::abs(rapidity) > kstarBkgConfig.KStarMaxRap) + continue; + + histos.fill(HIST("KStarBkg/h2dMixedKStarMassVsPt"), mass, pt); + histos.fill(HIST("KStarBkg/h3dMixedKStarMassVsPt"), + getCentralityRun3Bkg(coll1), pt, mass); + histos.fill(HIST("KStarBkg/h3dMixedKStarPtVsOPAngle"), + openAngle, pt, mass); + } + } + } + + // γ(coll1) × K0s(coll2) + if (!photons1.empty() && !kshorts2.empty()) { + for (int pIdx : photons1) { + auto photon = fullV0s.rawIteratorAt(pIdx); + float pP = std::hypot(photon.px(), photon.py(), photon.pz()); + ROOT::Math::PxPyPzEVector FourMomPhoton( + photon.px(), photon.py(), photon.pz(), pP); + + for (int kIdx : kshorts2) { + auto kshort = fullV0s.rawIteratorAt(kIdx); + float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); + ROOT::Math::PxPyPzEVector FourMomKShort( + kshort.px(), kshort.py(), kshort.pz(), + std::sqrt(kP * kP + + o2::constants::physics::MassK0Short * + o2::constants::physics::MassK0Short)); + + auto FourMomKStar = FourMomPhoton + FourMomKShort; + + double cosOA = FourMomPhoton.Vect().Dot(FourMomKShort.Vect()) / + (FourMomPhoton.P() * FourMomKShort.P()); + double openAngle = std::acos(cosOA); + float mass = FourMomKStar.M(); + float pt = FourMomKStar.Pt(); + // Rapidity computed under the K*(892) mass hypothesis (NOT the actual pair + // invariant mass) to match the same-event rotational background and the + // buildKStar signal selection, so the rapidity acceptance is identical for + // signal and all backgrounds. + float rapidity = RecoDecay::y(std::array{static_cast(FourMomKStar.Px()), + static_cast(FourMomKStar.Py()), + static_cast(FourMomKStar.Pz())}, + o2::constants::physics::MassK0Star892); + + if (openAngle > kstarBkgConfig.KStarMaxOPAngle) + continue; + if (std::abs(rapidity) > kstarBkgConfig.KStarMaxRap) + continue; + + histos.fill(HIST("KStarBkg/h2dMixedKStarMassVsPt"), mass, pt); + histos.fill(HIST("KStarBkg/h3dMixedKStarMassVsPt"), + getCentralityRun3Bkg(coll1), pt, mass); + histos.fill(HIST("KStarBkg/h3dMixedKStarPtVsOPAngle"), + openAngle, pt, mass); + } + } + } + } + } + + //_______________________________________________ + // Data process: same-event rotational + mixed-event K* background + void processKStarBkg(soa::Join const& collisions, + V0StandardDerivedDatas const& fullV0s, + dauTracks const&) + { + calculateKStarBkg(collisions, fullV0s); + } + + PROCESS_SWITCH(k892hadronphotonBkg, processKStarBkg, "Compute K* same-event rotational and mixed-event background (data)", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} diff --git a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx index e4fbc8c83f8..9d215ac4ebd 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx @@ -25,6 +25,7 @@ #include "Common/CCDB/EventSelectionParams.h" #include "Common/CCDB/ctpRateFetcher.h" +#include "Common/Core/RecoDecay.h" #include #include @@ -767,7 +768,7 @@ struct k892hadronphoton { //_______________________________________ // Gamma MC association - if (kstar.photonPDGCode() == PDG_t::kGamma) { + if (std::abs(kstar.photonPDGCode()) == PDG_t::kGamma) { if (kstar.photonmcpt() > 0) { histos.fill(HIST("BeforeSel/MC/Reso/h3dGammaPtResoVsTPCCR"), 1.f / kstar.kshortmcpt(), 1.f / kstar.kshortPt() - 1.f / kstar.kshortmcpt(), -1 * kstar.photonNegTPCCrossedRows()); // 1/pT resolution histos.fill(HIST("BeforeSel/MC/Reso/h3dGammaPtResoVsTPCCR"), 1.f / kstar.kshortmcpt(), 1.f / kstar.kshortPt() - 1.f / kstar.kshortmcpt(), kstar.photonPosTPCCrossedRows()); // 1/pT resolution @@ -777,7 +778,7 @@ struct k892hadronphoton { //_______________________________________ // KShort MC association - if (kstar.kshortPDGCode() == PDG_t::kK0Short) { + if (std::abs(kstar.kshortPDGCode()) == PDG_t::kK0Short) { if (kstar.kshortmcpt() > 0) { histos.fill(HIST("BeforeSel/MC/Reso/h2dKShortPtResolution"), 1.f / kstar.kshortmcpt(), 1.f / kstar.kshortPt() - 1.f / kstar.kshortmcpt()); // 1/pT resolution histos.fill(HIST("BeforeSel/MC/Reso/h3dKShortPtResoVsTPCCR"), 1.f / kstar.kshortmcpt(), 1.f / kstar.kshortPt() - 1.f / kstar.kshortmcpt(), -1 * kstar.kshortNegTPCCrossedRows()); // 1/pT resolution @@ -813,24 +814,24 @@ struct k892hadronphoton { //_______________________________________ // Real Gamma x Real KShort - but not from the same kstar! - if ((PhotonPDGCode == PDG_t::kGamma) && (KShortPDGCode == PDG_t::kK0Short) && (!fIsKStar)) { + if ((!fIsKStar)) { //(std::abs(PhotonPDGCode) == PDG_t::kGamma) && (std::abs(KShortPDGCode) == PDG_t::kK0Short) && histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_TrueDaughters"), kstarpT, kstarMass); histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dTrueDaughtersMatrix"), KShortPDGCodeMother, PhotonPDGCodeMother); } //_______________________________________ // Real Gamma x fake KShort - if ((PhotonPDGCode == PDG_t::kGamma) && (KShortPDGCode != PDG_t::kK0Short)) + if ((std::abs(PhotonPDGCode) == PDG_t::kGamma) && (std::abs(KShortPDGCode) != PDG_t::kK0Short)) histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_TrueGammaFakeKShort"), kstarpT, kstarMass); //_______________________________________ // Fake Gamma x Real KShort - if ((PhotonPDGCode != PDG_t::kGamma) && ((KShortPDGCode == PDG_t::kK0Short))) + if ((std::abs(PhotonPDGCode) != PDG_t::kGamma) && ((std::abs(KShortPDGCode) == PDG_t::kK0Short))) histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_FakeGammaTrueKShort"), kstarpT, kstarMass); //_______________________________________ // Fake Gamma x Fake KShort - if ((PhotonPDGCode != PDG_t::kGamma) && (KShortPDGCode != PDG_t::kK0Short)) + if ((std::abs(PhotonPDGCode) != PDG_t::kGamma) && (std::abs(KShortPDGCode) != PDG_t::kK0Short)) histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_FakeDaughters"), kstarpT, kstarMass); } @@ -997,7 +998,7 @@ struct k892hadronphoton { "CosPA", "Y", "TPCCR", "DauITSCls", "Lifetime", "TPCTOFPID", "DCADauToPV", "Mass"}; - if (PDGRequired == PDG_t::kGamma) { + if (std::abs(PDGRequired) == PDG_t::kGamma) { if constexpr (selection_index >= 0 && selection_index < (int)std::size(PhotonSelsLocal)) { histos.fill(HIST("Selection/Photon/hCandidateSel"), selection_index); histos.fill(HIST("Selection/Photon/h2d") + HIST(PhotonSelsLocal[selection_index]), kstar.photonPt(), kstar.photonMass()); @@ -1005,7 +1006,7 @@ struct k892hadronphoton { } } - if (PDGRequired == PDG_t::kK0Short) { + if (std::abs(PDGRequired) == PDG_t::kK0Short) { if constexpr (selection_index >= 0 && selection_index < (int)std::size(KShortSelsLocal)) { histos.fill(HIST("Selection/KShort/hCandidateSel"), selection_index); histos.fill(HIST("Selection/KShort/h2d") + HIST(KShortSelsLocal[selection_index]), kstar.kshortPt(), kstar.kshortMass()); @@ -1144,7 +1145,6 @@ struct k892hadronphoton { // return false; // if (kshortSelections.fselKShortTOFPID && (TMath::Abs(cand.lambdaPiTOFNSigma()) > kshortSelections.KShortPiMaxTOFNSigmas)) // return false; - // DCA Selection fillSelHistos<9>(cand, PDG_t::kK0Short); if ((TMath::Abs(cand.kshortDCAPosPV()) < kshortSelections.KShortMinDCAPosToPv) || (TMath::Abs(cand.kshortDCANegPV()) < kshortSelections.KShortMinDCANegToPv)) From 46e9f1eb94c744081df549d40be3a0f55d12f69f Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 18 Jun 2026 13:19:32 +0000 Subject: [PATCH 02/13] Please consider the following formatting changes --- PWGLF/TableProducer/Strangeness/sigma0builder.cxx | 4 ++-- PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx | 2 +- PWGLF/Tasks/Resonances/k892hadronphoton.cxx | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx index c3c04a272ea..95c7f7d1243 100644 --- a/PWGLF/TableProducer/Strangeness/sigma0builder.cxx +++ b/PWGLF/TableProducer/Strangeness/sigma0builder.cxx @@ -312,7 +312,7 @@ struct sigma0builder { } genSelections; struct : ConfigurableGroup { - // base properties + // base properties std::string prefix = "axisConfig"; // JSON group name ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 30.0f, 35.0f, 40.0f, 50.0f}, "pt axis for analysis"}; ConfigurableAxis axisCentrality{"axisCentrality", {VARIABLE_WIDTH, 0.0f, 5.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f, 90.0f, 100.0f, 110.0f}, "Centrality"}; @@ -403,7 +403,7 @@ struct sigma0builder { } histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(19, "Below min IR"); histos.get(HIST("hEventSelection"))->GetXaxis()->SetBinLabel(20, "Above max IR"); - + if (fGetIR) { histos.add("GeneralQA/hRunNumberNegativeIR", "", kTH1D, {{1, 0., 1.}}); histos.add("GeneralQA/hInteractionRate", "hInteractionRate", kTH1D, {axisConfig.axisIRBinning}); diff --git a/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx index e8c2ed111a3..b87f2573cf7 100644 --- a/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx @@ -552,7 +552,7 @@ struct k892hadronphotonBkg { for (int irot = 0; irot < kstarBkgConfig.nBkgRot; ++irot) { float theta = rotRng.Uniform(o2::constants::math::PI - o2::constants::math::PI / kstarBkgConfig.rotationalCut, - o2::constants::math::PI + o2::constants::math::PI / kstarBkgConfig.rotationalCut); + o2::constants::math::PI + o2::constants::math::PI / kstarBkgConfig.rotationalCut); ROOT::Math::PtEtaPhiMVector kRot(kPt, kEta, kPhi + theta, o2::constants::physics::MassK0Short); diff --git a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx index 9d215ac4ebd..0008533c90d 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx @@ -814,7 +814,7 @@ struct k892hadronphoton { //_______________________________________ // Real Gamma x Real KShort - but not from the same kstar! - if ((!fIsKStar)) { //(std::abs(PhotonPDGCode) == PDG_t::kGamma) && (std::abs(KShortPDGCode) == PDG_t::kK0Short) && + if ((!fIsKStar)) { //(std::abs(PhotonPDGCode) == PDG_t::kGamma) && (std::abs(KShortPDGCode) == PDG_t::kK0Short) && histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_TrueDaughters"), kstarpT, kstarMass); histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dTrueDaughtersMatrix"), KShortPDGCodeMother, PhotonPDGCodeMother); } From c1ea3a2167468d464167555f5bd71493929a4258 Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Thu, 18 Jun 2026 15:38:18 +0200 Subject: [PATCH 03/13] MegaLinter fixes --- PWGLF/Tasks/Resonances/CMakeLists.txt | 2 +- PWGLF/Tasks/Resonances/k892hadronphoton.cxx | 4 ++-- .../{K892hadronphotonBkg.cxx => k892hadronphotonBkg.cxx} | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) rename PWGLF/Tasks/Resonances/{K892hadronphotonBkg.cxx => k892hadronphotonBkg.cxx} (99%) diff --git a/PWGLF/Tasks/Resonances/CMakeLists.txt b/PWGLF/Tasks/Resonances/CMakeLists.txt index 63d99f1ddfe..f510a90fa75 100644 --- a/PWGLF/Tasks/Resonances/CMakeLists.txt +++ b/PWGLF/Tasks/Resonances/CMakeLists.txt @@ -310,7 +310,7 @@ o2physics_add_dpl_workflow(k892hadronphoton COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(k892hadronphotonbkg - SOURCES K892hadronphotonBkg.cxx + SOURCES k892hadronphotonBkg.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::AnalysisCCDB COMPONENT_NAME Analysis) diff --git a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx index 0008533c90d..e6c35fe5ed6 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx @@ -999,7 +999,7 @@ struct k892hadronphoton { "TPCTOFPID", "DCADauToPV", "Mass"}; if (std::abs(PDGRequired) == PDG_t::kGamma) { - if constexpr (selection_index >= 0 && selection_index < (int)std::size(PhotonSelsLocal)) { + if constexpr (selection_index >= 0 && selection_index < static_cast(std::size(PhotonSelsLocal))) { histos.fill(HIST("Selection/Photon/hCandidateSel"), selection_index); histos.fill(HIST("Selection/Photon/h2d") + HIST(PhotonSelsLocal[selection_index]), kstar.photonPt(), kstar.photonMass()); histos.fill(HIST("Selection/KStar/h2dPhoton") + HIST(PhotonSelsLocal[selection_index]), kstar.pt(), kstar.kstarMass()); @@ -1007,7 +1007,7 @@ struct k892hadronphoton { } if (std::abs(PDGRequired) == PDG_t::kK0Short) { - if constexpr (selection_index >= 0 && selection_index < (int)std::size(KShortSelsLocal)) { + if constexpr (selection_index >= 0 && selection_index < static_cast(std::size(KShortSelsLocal))) { histos.fill(HIST("Selection/KShort/hCandidateSel"), selection_index); histos.fill(HIST("Selection/KShort/h2d") + HIST(KShortSelsLocal[selection_index]), kstar.kshortPt(), kstar.kshortMass()); histos.fill(HIST("Selection/KStar/h2dKShort") + HIST(KShortSelsLocal[selection_index]), kstar.pt(), kstar.kstarMass()); diff --git a/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx similarity index 99% rename from PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx rename to PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index b87f2573cf7..07d9aebf155 100644 --- a/PWGLF/Tasks/Resonances/K892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -645,16 +645,16 @@ struct k892hadronphotonBkg { histos.fill(HIST("KStarBkg/h2dCentralityCollPair"), getCentralityRun3Bkg(coll1), getCentralityRun3Bkg(coll2)); - if (std::abs(int64_t(coll1.globalIndex()) - int64_t(coll2.globalIndex())) < kstarBkgConfig.deltaCollision) + if (std::abs(static_cast(coll1.globalIndex()) - static_cast(coll2.globalIndex())) < kstarBkgConfig.deltaCollision) continue; - +xww auto const& photons1 = photonPool[coll1.globalIndex()]; auto const& kshorts1 = kshortPool[coll1.globalIndex()]; auto const& photons2 = photonPool[coll2.globalIndex()]; auto const& kshorts2 = kshortPool[coll2.globalIndex()]; // K0s(coll1) × γ(coll2) - if (!kshorts1.empty() && !photons2.empty()) { + if (!kshorts1.empty() && !photons2.empty()) {xw for (int kIdx : kshorts1) { auto kshort = fullV0s.rawIteratorAt(kIdx); float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); From c2647823f1753d46b47d054c4d90e1a9a9f03097 Mon Sep 17 00:00:00 2001 From: Oussama3030 <59825001+Oussama3030@users.noreply.github.com> Date: Thu, 18 Jun 2026 15:42:05 +0200 Subject: [PATCH 04/13] Fix syntax errors in k892hadronphotonBkg.cxx --- PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index 07d9aebf155..5d3277d367e 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -647,14 +647,14 @@ struct k892hadronphotonBkg { if (std::abs(static_cast(coll1.globalIndex()) - static_cast(coll2.globalIndex())) < kstarBkgConfig.deltaCollision) continue; -xww + auto const& photons1 = photonPool[coll1.globalIndex()]; auto const& kshorts1 = kshortPool[coll1.globalIndex()]; auto const& photons2 = photonPool[coll2.globalIndex()]; auto const& kshorts2 = kshortPool[coll2.globalIndex()]; // K0s(coll1) × γ(coll2) - if (!kshorts1.empty() && !photons2.empty()) {xw + if (!kshorts1.empty() && !photons2.empty()) { for (int kIdx : kshorts1) { auto kshort = fullV0s.rawIteratorAt(kIdx); float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); From 3babe7762608e34eb5900d8f2e900b783a537136 Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Fri, 19 Jun 2026 10:25:51 +0200 Subject: [PATCH 05/13] minor fixes --- PWGLF/Tasks/Resonances/k892hadronphoton.cxx | 1 - PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx | 8 ++------ 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx index e6c35fe5ed6..3045ab4647b 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx @@ -25,7 +25,6 @@ #include "Common/CCDB/EventSelectionParams.h" #include "Common/CCDB/ctpRateFetcher.h" -#include "Common/Core/RecoDecay.h" #include #include diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index 5d3277d367e..75c01abc59f 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -537,10 +537,6 @@ struct k892hadronphotonBkg { for (int kIdx : kshortIndices) { auto kshort = fullV0s.rawIteratorAt(kIdx); - float kPt = kshort.pt(); - float kEta = kshort.eta(); - float kPhi = kshort.phi(); - for (int pIdx : photonIndices) { auto photon = fullV0s.rawIteratorAt(pIdx); @@ -554,7 +550,7 @@ struct k892hadronphotonBkg { float theta = rotRng.Uniform(o2::constants::math::PI - o2::constants::math::PI / kstarBkgConfig.rotationalCut, o2::constants::math::PI + o2::constants::math::PI / kstarBkgConfig.rotationalCut); - ROOT::Math::PtEtaPhiMVector kRot(kPt, kEta, kPhi + theta, o2::constants::physics::MassK0Short); + ROOT::Math::PtEtaPhiMVector kRot(kshort.pt(), kshort.eta(), kshort.phi() + theta, o2::constants::physics::MassK0Short); auto kstar = pGamma + kRot; @@ -751,7 +747,7 @@ struct k892hadronphotonBkg { //_______________________________________________ // Data process: same-event rotational + mixed-event K* background - void processKStarBkg(soa::Join const& collisions, + void processKStarBkg(soa::Join const& collisions, V0StandardDerivedDatas const& fullV0s, dauTracks const&) { From 29c2ecc1541b0f6890f6806546845989a38026cd Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Fri, 19 Jun 2026 11:32:11 +0200 Subject: [PATCH 06/13] o2linter fixes --- PWGLF/Tasks/Resonances/k892hadronphoton.cxx | 216 +++++++++--------- .../Tasks/Resonances/k892hadronphotonBkg.cxx | 162 ++++++------- 2 files changed, 189 insertions(+), 189 deletions(-) diff --git a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx index 3045ab4647b..da9f968009b 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx @@ -134,65 +134,65 @@ struct k892hadronphoton { //// K0Short criteria: struct : ConfigurableGroup { - Configurable KShort_MLThreshold{"KShort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; - Configurable KShortMinDCANegToPv{"KShortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; - Configurable KShortMinDCAPosToPv{"KShortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; - Configurable KShortMaxDCAV0Dau{"KShortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; - Configurable KShortMinv0radius{"KShortMinv0radius", 0.0, "Min V0 radius (cm)"}; - Configurable KShortMaxv0radius{"KShortMaxv0radius", 40, "Max V0 radius (cm)"}; - Configurable KShortMinQt{"KShortMinQt", 0.1, "Min kshort qt value (AP plot) (GeV/c)"}; - Configurable KShortMaxQt{"KShortMaxQt", 2.5, "Max kshort qt value (AP plot) (GeV/c)"}; - Configurable KShortMinAlpha{"KShortMinAlpha", 0.0, "Min kshort alpha absolute value (AP plot)"}; - Configurable KShortMaxAlpha{"KShortMaxAlpha", 1.0, "Max kshort alpha absolute value (AP plot)"}; - Configurable KShortMinv0cospa{"KShortMinv0cospa", 0.95, "Min V0 CosPA"}; - Configurable KShortMaxLifeTime{"KShortMaxLifeTime", 30, "Max lifetime"}; - Configurable KShortWindow{"KShortWindow", 0.015, "Mass window around expected (in GeV/c2)"}; - Configurable KShortMaxRap{"KShortMaxRap", 0.8, "Max kshort rapidity"}; - Configurable KShortMaxDauEta{"KShortMaxDauEta", 0.8, "Max pseudorapidity of daughter tracks"}; + Configurable kshort_MLThreshold{"kshort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; + Configurable kshortMinDCANegToPv{"kshortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; + Configurable kshortMinDCAPosToPv{"kshortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; + Configurable kshortMaxDCAV0Dau{"kshortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; + Configurable kshortMinv0radius{"kshortMinv0radius", 0.0, "Min V0 radius (cm)"}; + Configurable kshortMaxv0radius{"kshortMaxv0radius", 40, "Max V0 radius (cm)"}; + Configurable kshortMinQt{"kshortMinQt", 0.1, "Min kshort qt value (AP plot) (GeV/c)"}; + Configurable kshortMaxQt{"kshortMaxQt", 2.5, "Max kshort qt value (AP plot) (GeV/c)"}; + Configurable kshortMinAlpha{"kshortMinAlpha", 0.0, "Min kshort alpha absolute value (AP plot)"}; + Configurable kshortMaxAlpha{"kshortMaxAlpha", 1.0, "Max kshort alpha absolute value (AP plot)"}; + Configurable kshortMinv0cospa{"kshortMinv0cospa", 0.95, "Min V0 CosPA"}; + Configurable kshortMaxLifeTime{"kshortMaxLifeTime", 30, "Max lifetime"}; + Configurable kshortWindow{"kshortWindow", 0.015, "Mass window around expected (in GeV/c2)"}; + Configurable kshortMaxRap{"kshortMaxRap", 0.8, "Max kshort rapidity"}; + Configurable kshortMaxDauEta{"kshortMaxDauEta", 0.8, "Max pseudorapidity of daughter tracks"}; Configurable fselKShortTPCPID{"fselKShortTPCPID", true, "Flag to select kshort-like candidates using TPC NSigma."}; Configurable fselKShortTOFPID{"fselKShortTOFPID", false, "Flag to select kshort-like candidates using TOF NSigma."}; - Configurable KShortMaxTPCNSigmas{"KShortMaxTPCNSigmas", 1e+9, "Max TPC NSigmas for daughters"}; - // Configurable KShortPrMaxTOFNSigmas{"KShortPrMaxTOFNSigmas", 1e+9, "Max TOF NSigmas for daughters"}; - Configurable KShortPiMaxTOFNSigmas{"KShortPiMaxTOFNSigmas", 1e+9, "Max TOF NSigmas for daughters"}; - Configurable KShortMinTPCCrossedRows{"KShortMinTPCCrossedRows", 50, "Min daughter TPC Crossed Rows"}; - Configurable KShortMinITSclusters{"KShortMinITSclusters", 1, "minimum ITS clusters"}; - Configurable KShortRejectPosITSafterburner{"KShortRejectPosITSafterburner", false, "reject positive track formed out of afterburner ITS tracks"}; - Configurable KShortRejectNegITSafterburner{"KShortRejectNegITSafterburner", false, "reject negative track formed out of afterburner ITS tracks"}; + Configurable kshortMaxTPCNSigmas{"kshortMaxTPCNSigmas", 1e+9, "Max TPC NSigmas for daughters"}; + // Configurable kshortMaxTOFNSigmas{"kshortMaxTOFNSigmas", 1e+9, "Max TOF NSigmas for daughters"}; + Configurable kshortPiMaxTOFNSigmas{"kshortPiMaxTOFNSigmas", 1e+9, "Max TOF NSigmas for daughters"}; + Configurable kshortMinTPCCrossedRows{"kshortMinTPCCrossedRows", 50, "Min daughter TPC Crossed Rows"}; + Configurable kshortMinITSclusters{"kshortMinITSclusters", 1, "minimum ITS clusters"}; + Configurable kshortRejectPosITSafterburner{"kshortRejectPosITSafterburner", false, "reject positive track formed out of afterburner ITS tracks"}; + Configurable kshortRejectNegITSafterburner{"kshortRejectNegITSafterburner", false, "reject negative track formed out of afterburner ITS tracks"}; } kshortSelections; //// Photon criteria: struct : ConfigurableGroup { - Configurable Gamma_MLThreshold{"Gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas"}; - Configurable Photonv0TypeSel{"Photonv0TypeSel", 7, "select on a certain V0 type (leave negative if no selection desired)"}; - Configurable PhotonMinDCADauToPv{"PhotonMinDCADauToPv", 0.0, "Min DCA daughter To PV (cm)"}; - Configurable PhotonMaxDCAV0Dau{"PhotonMaxDCAV0Dau", 3.5, "Max DCA V0 Daughters (cm)"}; - Configurable PhotonMinTPCCrossedRows{"PhotonMinTPCCrossedRows", 30, "Min daughter TPC Crossed Rows"}; - Configurable PhotonMinTPCNSigmas{"PhotonMinTPCNSigmas", -7, "Min TPC NSigmas for daughters"}; - Configurable PhotonMaxTPCNSigmas{"PhotonMaxTPCNSigmas", 7, "Max TPC NSigmas for daughters"}; - Configurable PhotonMinPt{"PhotonMinPt", 0.0, "Min photon pT (GeV/c)"}; - Configurable PhotonMaxPt{"PhotonMaxPt", 50.0, "Max photon pT (GeV/c)"}; - Configurable PhotonMaxRap{"PhotonMaxRap", 0.5, "Max photon rapidity"}; - Configurable PhotonMinRadius{"PhotonMinRadius", 3.0, "Min photon conversion radius (cm)"}; - Configurable PhotonMaxRadius{"PhotonMaxRadius", 115, "Max photon conversion radius (cm)"}; - Configurable PhotonMaxZ{"PhotonMaxZ", 240, "Max photon conversion point z value (cm)"}; - Configurable PhotonMaxQt{"PhotonMaxQt", 0.05, "Max photon qt value (AP plot) (GeV/c)"}; - Configurable PhotonMaxAlpha{"PhotonMaxAlpha", 0.95, "Max photon alpha absolute value (AP plot)"}; - Configurable PhotonMinV0cospa{"PhotonMinV0cospa", 0.80, "Min V0 CosPA"}; - Configurable PhotonMaxMass{"PhotonMaxMass", 0.10, "Max photon mass (GeV/c^{2})"}; - Configurable PhotonPsiPairMax{"PhotonPsiPairMax", 1e+9, "maximum psi angle of the track pair"}; - Configurable PhotonMaxDauEta{"PhotonMaxDauEta", 0.8, "Max pseudorapidity of daughter tracks"}; - Configurable PhotonLineCutZ0{"PhotonLineCutZ0", 7.0, "The offset for the linecute used in the Z vs R plot"}; - Configurable PhotonPhiMin1{"PhotonPhiMin1", -1, "Phi min value to reject photons, region 1 (leave negative if no selection desired)"}; - Configurable PhotonPhiMax1{"PhotonPhiMax1", -1, "Phi max value to reject photons, region 1 (leave negative if no selection desired)"}; - Configurable PhotonPhiMin2{"PhotonPhiMin2", -1, "Phi max value to reject photons, region 2 (leave negative if no selection desired)"}; - Configurable PhotonPhiMax2{"PhotonPhiMax2", -1, "Phi min value to reject photons, region 2 (leave negative if no selection desired)"}; + Configurable gamma_MLThreshold{"gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas"}; + Configurable photonv0TypeSel{"photonv0TypeSel", 7, "select on a certain V0 type (leave negative if no selection desired)"}; + Configurable photonMinDCADauToPv{"photonMinDCADauToPv", 0.0, "Min DCA daughter To PV (cm)"}; + Configurable photonMaxDCAV0Dau{"photonMaxDCAV0Dau", 3.5, "Max DCA V0 Daughters (cm)"}; + Configurable photonMinTPCCrossedRows{"photonMinTPCCrossedRows", 30, "Min daughter TPC Crossed Rows"}; + Configurable photonMinTPCNSigmas{"photonMinTPCNSigmas", -7, "Min TPC NSigmas for daughters"}; + Configurable photonMaxTPCNSigmas{"photonMaxTPCNSigmas", 7, "Max TPC NSigmas for daughters"}; + Configurable photonMinPt{"photonMinPt", 0.0, "Min photon pT (GeV/c)"}; + Configurable photonMaxPt{"photonMaxPt", 50.0, "Max photon pT (GeV/c)"}; + Configurable photonMaxRap{"photonMaxRap", 0.5, "Max photon rapidity"}; + Configurable photonMinRadius{"photonMinRadius", 3.0, "Min photon conversion radius (cm)"}; + Configurable photonMaxRadius{"photonMaxRadius", 115, "Max photon conversion radius (cm)"}; + Configurable photonMaxZ{"photonMaxZ", 240, "Max photon conversion point z value (cm)"}; + Configurable photonMaxQt{"photonMaxQt", 0.05, "Max photon qt value (AP plot) (GeV/c)"}; + Configurable photonMaxAlpha{"photonMaxAlpha", 0.95, "Max photon alpha absolute value (AP plot)"}; + Configurable photonMinV0cospa{"photonMinV0cospa", 0.80, "Min V0 CosPA"}; + Configurable photonMaxMass{"photonMaxMass", 0.10, "Max photon mass (GeV/c^{2})"}; + Configurable photonPsiPairMax{"photonPsiPairMax", 1e+9, "maximum psi angle of the track pair"}; + Configurable photonMaxDauEta{"photonMaxDauEta", 0.8, "Max pseudorapidity of daughter tracks"}; + Configurable photonLineCutZ0{"photonLineCutZ0", 7.0, "The offset for the linecute used in the Z vs R plot"}; + Configurable photonPhiMin1{"photonPhiMin1", -1, "Phi min value to reject photons, region 1 (leave negative if no selection desired)"}; + Configurable photonPhiMax1{"photonPhiMax1", -1, "Phi max value to reject photons, region 1 (leave negative if no selection desired)"}; + Configurable photonPhiMin2{"photonPhiMin2", -1, "Phi max value to reject photons, region 2 (leave negative if no selection desired)"}; + Configurable photonPhiMax2{"photonPhiMax2", -1, "Phi min value to reject photons, region 2 (leave negative if no selection desired)"}; } photonSelections; struct : ConfigurableGroup { - Configurable KStarMaxRap{"KStarMaxRap", 0.5, "Max kstar rapidity"}; - Configurable KStarMaxRadius{"KStarMaxRadius", 200, "Max kstar decay radius"}; - Configurable KStarMaxDCADau{"KStarMaxDCADau", 50, "Max kstar DCA between daughters"}; - Configurable KStarMaxOPAngle{"KStarMaxOPAngle", 7, "Max kstar OP Angle between daughters"}; + Configurable kstarMaxRap{"kstarMaxRap", 0.5, "Max kstar rapidity"}; + Configurable kstarMaxRadius{"kstarMaxRadius", 200, "Max kstar decay radius"}; + Configurable kstarMaxDCADau{"kstarMaxDCADau", 50, "Max kstar DCA between daughters"}; + Configurable kstarMaxOPAngle{"kstarMaxOPAngle", 7, "Max kstar OP Angle between daughters"}; } kstarSelections; // Axis @@ -237,7 +237,7 @@ struct k892hadronphoton { ConfigurableAxis axisCandSel{"axisCandSel", {20, 0.5f, +20.5f}, "Candidate Selection"}; // ML - ConfigurableAxis MLProb{"MLOutput", {100, 0.0f, 1.0f}, ""}; + ConfigurableAxis mlProb{"mlOutput", {100, 0.0f, 1.0f}, ""}; void init(InitContext const&) { @@ -450,7 +450,7 @@ struct k892hadronphoton { // Check whether the collision passes our collision selections // Should work with collisions, mccollisions, stracollisions and stramccollisions tables! template - bool IsEventAccepted(TCollision const& collision, bool fillHists) + bool isEventAccepted(TCollision const& collision, bool fillHists) { if (fillHists) histos.fill(HIST("hEventSelection"), 0. /* all collisions */); @@ -599,7 +599,7 @@ struct k892hadronphoton { for (auto const& collision : groupedCollisions) { // consider event selections in the recoed <-> gen collision association, for the denominator (or numerator) of the efficiency (or signal loss)? if (eventSelections.useEvtSelInDenomEff) { - if (!IsEventAccepted(collision, false)) { + if (!isEventAccepted(collision, false)) { continue; } } @@ -648,7 +648,7 @@ struct k892hadronphoton { int nCollisions = 0; for (auto const& collision : groupedCollisions) { - if (!IsEventAccepted(collision, false)) { + if (!isEventAccepted(collision, false)) { continue; } @@ -736,29 +736,29 @@ struct k892hadronphoton { int retrieveV0TrackCode(TKStarObject const& kstar) { - int TrkCode = 10; // 1: TPC-only, 2: TPC+Something, 3: ITS-Only, 4: ITS+TPC + Something, 10: anything else + int trkCode = 10; // 1: TPC-only, 2: TPC+Something, 3: ITS-Only, 4: ITS+TPC + Something, 10: anything else if (isGamma) { if (kstar.photonPosTrackCode() == 1 && kstar.photonNegTrackCode() == 1) - TrkCode = 1; + trkCode = 1; if ((kstar.photonPosTrackCode() != 1 && kstar.photonNegTrackCode() == 1) || (kstar.photonPosTrackCode() == 1 && kstar.photonNegTrackCode() != 1)) - TrkCode = 2; + trkCode = 2; if (kstar.photonPosTrackCode() == 3 && kstar.photonNegTrackCode() == 3) - TrkCode = 3; + trkCode = 3; if (kstar.photonPosTrackCode() == 2 || kstar.photonNegTrackCode() == 2) - TrkCode = 4; + trkCode = 4; } else { if (kstar.kshortPosTrackCode() == 1 && kstar.kshortNegTrackCode() == 1) - TrkCode = 1; + trkCode = 1; if ((kstar.kshortPosTrackCode() != 1 && kstar.kshortNegTrackCode() == 1) || (kstar.kshortPosTrackCode() == 1 && kstar.kshortNegTrackCode() != 1)) - TrkCode = 2; + trkCode = 2; if (kstar.kshortPosTrackCode() == 3 && kstar.kshortNegTrackCode() == 3) - TrkCode = 3; + trkCode = 3; if (kstar.kshortPosTrackCode() == 2 || kstar.kshortNegTrackCode() == 2) - TrkCode = 4; + trkCode = 4; } - return TrkCode; + return trkCode; } template @@ -842,14 +842,14 @@ struct k892hadronphoton { static constexpr std::string_view MainDir[] = {"BeforeSel", "AfterSel"}; // Get V0trackCode - int GammaTrkCode = retrieveV0TrackCode(kstar); - int KShortTrkCode = retrieveV0TrackCode(kstar); + int gammaTrkCode = retrieveV0TrackCode(kstar); + int kshortTrkCode = retrieveV0TrackCode(kstar); - float photonRZLineCut = TMath::Abs(kstar.photonZconv()) * TMath::Tan(2 * TMath::ATan(TMath::Exp(-photonSelections.PhotonMaxDauEta))) - photonSelections.PhotonLineCutZ0; + float photonRZLineCut = TMath::Abs(kstar.photonZconv()) * TMath::Tan(2 * TMath::ATan(TMath::Exp(-photonSelections.photonMaxDauEta))) - photonSelections.photonLineCutZ0; float centrality = doPPAnalysis ? collision.centFT0M() : collision.centFT0C(); //_______________________________________ // Photon - histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hTrackCode"), GammaTrkCode); + histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hTrackCode"), gammaTrkCode); histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hV0Type"), kstar.photonV0Type()); histos.fill(HIST(MainDir[mode]) + HIST("/Photon/hDCANegToPV"), kstar.photonDCANegPV()); @@ -875,7 +875,7 @@ struct k892hadronphoton { //_______________________________________ // KShorts - histos.fill(HIST(MainDir[mode]) + HIST("/KShort/hTrackCode"), KShortTrkCode); + histos.fill(HIST(MainDir[mode]) + HIST("/KShort/hTrackCode"), kshortTrkCode); histos.fill(HIST(MainDir[mode]) + HIST("/KShort/hRadius"), kstar.kshortRadius()); histos.fill(HIST(MainDir[mode]) + HIST("/KShort/hDCADau"), kstar.kshortDCADau()); histos.fill(HIST(MainDir[mode]) + HIST("/KShort/hCosPA"), kstar.kshortCosPA()); @@ -1019,66 +1019,66 @@ struct k892hadronphoton { bool selectPhoton(TV0Object const& cand) { fillSelHistos<0>(cand, PDG_t::kGamma); - if (cand.photonV0Type() != photonSelections.Photonv0TypeSel && photonSelections.Photonv0TypeSel > -1) + if (cand.photonV0Type() != photonSelections.photonv0TypeSel && photonSelections.photonv0TypeSel > -1) return false; fillSelHistos<1>(cand, PDG_t::kGamma); - if ((TMath::Abs(cand.photonDCAPosPV()) < photonSelections.PhotonMinDCADauToPv) || (TMath::Abs(cand.photonDCANegPV()) < photonSelections.PhotonMinDCADauToPv)) + if ((TMath::Abs(cand.photonDCAPosPV()) < photonSelections.photonMinDCADauToPv) || (TMath::Abs(cand.photonDCANegPV()) < photonSelections.photonMinDCADauToPv)) return false; fillSelHistos<2>(cand, PDG_t::kGamma); - if (TMath::Abs(cand.photonDCADau()) > photonSelections.PhotonMaxDCAV0Dau) + if (TMath::Abs(cand.photonDCADau()) > photonSelections.photonMaxDCAV0Dau) return false; fillSelHistos<3>(cand, PDG_t::kGamma); - if ((cand.photonPosTPCCrossedRows() < photonSelections.PhotonMinTPCCrossedRows) || (cand.photonNegTPCCrossedRows() < photonSelections.PhotonMinTPCCrossedRows)) + if ((cand.photonPosTPCCrossedRows() < photonSelections.photonMinTPCCrossedRows) || (cand.photonNegTPCCrossedRows() < photonSelections.photonMinTPCCrossedRows)) return false; fillSelHistos<4>(cand, PDG_t::kGamma); - if (((cand.photonPosTPCNSigmaEl() < photonSelections.PhotonMinTPCNSigmas) || (cand.photonPosTPCNSigmaEl() > photonSelections.PhotonMaxTPCNSigmas))) + if (((cand.photonPosTPCNSigmaEl() < photonSelections.photonMinTPCNSigmas) || (cand.photonPosTPCNSigmaEl() > photonSelections.photonMaxTPCNSigmas))) return false; - if (((cand.photonNegTPCNSigmaEl() < photonSelections.PhotonMinTPCNSigmas) || (cand.photonNegTPCNSigmaEl() > photonSelections.PhotonMaxTPCNSigmas))) + if (((cand.photonNegTPCNSigmaEl() < photonSelections.photonMinTPCNSigmas) || (cand.photonNegTPCNSigmaEl() > photonSelections.photonMaxTPCNSigmas))) return false; fillSelHistos<5>(cand, PDG_t::kGamma); - if ((cand.photonPt() < photonSelections.PhotonMinPt) || (cand.photonPt() > photonSelections.PhotonMaxPt)) + if ((cand.photonPt() < photonSelections.photonMinPt) || (cand.photonPt() > photonSelections.photonMaxPt)) return false; fillSelHistos<6>(cand, PDG_t::kGamma); - if ((TMath::Abs(cand.photonY()) > photonSelections.PhotonMaxRap) || (TMath::Abs(cand.photonPosEta()) > photonSelections.PhotonMaxDauEta) || (TMath::Abs(cand.photonNegEta()) > photonSelections.PhotonMaxDauEta)) + if ((TMath::Abs(cand.photonY()) > photonSelections.photonMaxRap) || (TMath::Abs(cand.photonPosEta()) > photonSelections.photonMaxDauEta) || (TMath::Abs(cand.photonNegEta()) > photonSelections.photonMaxDauEta)) return false; fillSelHistos<7>(cand, PDG_t::kGamma); - if ((cand.photonRadius() < photonSelections.PhotonMinRadius) || (cand.photonRadius() > photonSelections.PhotonMaxRadius)) + if ((cand.photonRadius() < photonSelections.photonMinRadius) || (cand.photonRadius() > photonSelections.photonMaxRadius)) return false; fillSelHistos<8>(cand, PDG_t::kGamma); - float photonRZLineCut = TMath::Abs(cand.photonZconv()) * TMath::Tan(2 * TMath::ATan(TMath::Exp(-photonSelections.PhotonMaxDauEta))) - photonSelections.PhotonLineCutZ0; - if ((TMath::Abs(cand.photonRadius()) < photonRZLineCut) || (TMath::Abs(cand.photonZconv()) > photonSelections.PhotonMaxZ)) + float photonRZLineCut = TMath::Abs(cand.photonZconv()) * TMath::Tan(2 * TMath::ATan(TMath::Exp(-photonSelections.photonMaxDauEta))) - photonSelections.photonLineCutZ0; + if ((TMath::Abs(cand.photonRadius()) < photonRZLineCut) || (TMath::Abs(cand.photonZconv()) > photonSelections.photonMaxZ)) return false; fillSelHistos<9>(cand, PDG_t::kGamma); - if (cand.photonQt() > photonSelections.PhotonMaxQt) + if (cand.photonQt() > photonSelections.photonMaxQt) return false; - if (TMath::Abs(cand.photonAlpha()) > photonSelections.PhotonMaxAlpha) + if (TMath::Abs(cand.photonAlpha()) > photonSelections.photonMaxAlpha) return false; fillSelHistos<10>(cand, PDG_t::kGamma); - if (cand.photonCosPA() < photonSelections.PhotonMinV0cospa) + if (cand.photonCosPA() < photonSelections.photonMinV0cospa) return false; fillSelHistos<11>(cand, PDG_t::kGamma); - if (TMath::Abs(cand.photonPsiPair()) > photonSelections.PhotonPsiPairMax) + if (TMath::Abs(cand.photonPsiPair()) > photonSelections.photonPsiPairMax) return false; fillSelHistos<12>(cand, PDG_t::kGamma); - if ((((cand.photonPhi() > photonSelections.PhotonPhiMin1) && (cand.photonPhi() < photonSelections.PhotonPhiMax1)) || ((cand.photonPhi() > photonSelections.PhotonPhiMin2) && (cand.photonPhi() < photonSelections.PhotonPhiMax2))) && ((photonSelections.PhotonPhiMin1 != -1) && (photonSelections.PhotonPhiMax1 != -1) && (photonSelections.PhotonPhiMin2 != -1) && (photonSelections.PhotonPhiMax2 != -1))) + if ((((cand.photonPhi() > photonSelections.photonPhiMin1) && (cand.photonPhi() < photonSelections.photonPhiMax1)) || ((cand.photonPhi() > photonSelections.photonPhiMin2) && (cand.photonPhi() < photonSelections.photonPhiMax2))) && ((photonSelections.photonPhiMin1 != -1) && (photonSelections.photonPhiMax1 != -1) && (photonSelections.photonPhiMin2 != -1) && (photonSelections.photonPhiMax2 != -1))) return false; fillSelHistos<13>(cand, PDG_t::kGamma); - if (TMath::Abs(cand.photonMass()) > photonSelections.PhotonMaxMass) + if (TMath::Abs(cand.photonMass()) > photonSelections.photonMaxMass) return false; fillSelHistos<14>(cand, PDG_t::kGamma); @@ -1090,30 +1090,30 @@ struct k892hadronphoton { bool selectKShort(TV0Object const& cand) { fillSelHistos<0>(cand, PDG_t::kK0Short); - if ((cand.kshortRadius() < kshortSelections.KShortMinv0radius) || (cand.kshortRadius() > kshortSelections.KShortMaxv0radius)) + if ((cand.kshortRadius() < kshortSelections.kshortMinv0radius) || (cand.kshortRadius() > kshortSelections.kshortMaxv0radius)) return false; fillSelHistos<1>(cand, PDG_t::kK0Short); - if (TMath::Abs(cand.kshortDCADau()) > kshortSelections.KShortMaxDCAV0Dau) + if (TMath::Abs(cand.kshortDCADau()) > kshortSelections.kshortMaxDCAV0Dau) return false; fillSelHistos<2>(cand, PDG_t::kK0Short); - if ((cand.kshortQt() < kshortSelections.KShortMinQt) || (cand.kshortQt() > kshortSelections.KShortMaxQt)) + if ((cand.kshortQt() < kshortSelections.kshortMinQt) || (cand.kshortQt() > kshortSelections.kshortMaxQt)) return false; - if ((TMath::Abs(cand.kshortAlpha()) < kshortSelections.KShortMinAlpha) || (TMath::Abs(cand.kshortAlpha()) > kshortSelections.KShortMaxAlpha)) + if ((TMath::Abs(cand.kshortAlpha()) < kshortSelections.kshortMinAlpha) || (TMath::Abs(cand.kshortAlpha()) > kshortSelections.kshortMaxAlpha)) return false; fillSelHistos<3>(cand, PDG_t::kK0Short); - if (cand.kshortCosPA() < kshortSelections.KShortMinv0cospa) + if (cand.kshortCosPA() < kshortSelections.kshortMinv0cospa) return false; fillSelHistos<4>(cand, PDG_t::kK0Short); - if ((TMath::Abs(cand.kshortY()) > kshortSelections.KShortMaxRap) || (TMath::Abs(cand.kshortPosEta()) > kshortSelections.KShortMaxDauEta) || (TMath::Abs(cand.kshortNegEta()) > kshortSelections.KShortMaxDauEta)) + if ((TMath::Abs(cand.kshortY()) > kshortSelections.kshortMaxRap) || (TMath::Abs(cand.kshortPosEta()) > kshortSelections.kshortMaxDauEta) || (TMath::Abs(cand.kshortNegEta()) > kshortSelections.kshortMaxDauEta)) return false; fillSelHistos<5>(cand, PDG_t::kK0Short); - if ((cand.kshortPosTPCCrossedRows() < kshortSelections.KShortMinTPCCrossedRows) || (cand.kshortNegTPCCrossedRows() < kshortSelections.KShortMinTPCCrossedRows)) + if ((cand.kshortPosTPCCrossedRows() < kshortSelections.kshortMinTPCCrossedRows) || (cand.kshortNegTPCCrossedRows() < kshortSelections.kshortMinTPCCrossedRows)) return false; fillSelHistos<6>(cand, PDG_t::kK0Short); @@ -1121,37 +1121,37 @@ struct k892hadronphoton { // check minimum number of ITS clusters + reject ITS afterburner tracks if requested bool posIsFromAfterburner = cand.kshortPosChi2PerNcl() < 0; bool negIsFromAfterburner = cand.kshortNegChi2PerNcl() < 0; - if (cand.kshortPosITSCls() < kshortSelections.KShortMinITSclusters && (!kshortSelections.KShortRejectPosITSafterburner || posIsFromAfterburner)) + if (cand.kshortPosITSCls() < kshortSelections.kshortMinITSclusters && (!kshortSelections.kshortRejectPosITSafterburner || posIsFromAfterburner)) return false; - if (cand.kshortNegITSCls() < kshortSelections.KShortMinITSclusters && (!kshortSelections.KShortRejectNegITSafterburner || negIsFromAfterburner)) + if (cand.kshortNegITSCls() < kshortSelections.kshortMinITSclusters && (!kshortSelections.kshortRejectNegITSafterburner || negIsFromAfterburner)) return false; fillSelHistos<7>(cand, PDG_t::kK0Short); - if (cand.kshortLifeTime() > kshortSelections.KShortMaxLifeTime) + if (cand.kshortLifeTime() > kshortSelections.kshortMaxLifeTime) return false; // Separating kshort selections: fillSelHistos<8>(cand, PDG_t::kK0Short); // TPC Selection - if (kshortSelections.fselKShortTPCPID && (TMath::Abs(cand.kshortPosPiTPCNSigma()) > kshortSelections.KShortMaxTPCNSigmas)) + if (kshortSelections.fselKShortTPCPID && (TMath::Abs(cand.kshortPosPiTPCNSigma()) > kshortSelections.kshortMaxTPCNSigmas)) return false; - if (kshortSelections.fselKShortTPCPID && (TMath::Abs(cand.kshortNegPiTPCNSigma()) > kshortSelections.KShortMaxTPCNSigmas)) + if (kshortSelections.fselKShortTPCPID && (TMath::Abs(cand.kshortNegPiTPCNSigma()) > kshortSelections.kshortMaxTPCNSigmas)) return false; // // TOF Selection - // if (kshortSelections.fselKShortTOFPID && (TMath::Abs(cand.kshortPiTOFNSigma()) > kshortSelections.KShortPiMaxTOFNSigmas)) + // if (kshortSelections.fselKShortTOFPID && (TMath::Abs(cand.kshortPiTOFNSigma()) > kshortSelections.kshortPiMaxTOFNSigmas)) // return false; - // if (kshortSelections.fselKShortTOFPID && (TMath::Abs(cand.lambdaPiTOFNSigma()) > kshortSelections.KShortPiMaxTOFNSigmas)) + // if (kshortSelections.fselKShortTOFPID && (TMath::Abs(cand.lambdaPiTOFNSigma()) > kshortSelections.kshortPiMaxTOFNSigmas)) // return false; // DCA Selection fillSelHistos<9>(cand, PDG_t::kK0Short); - if ((TMath::Abs(cand.kshortDCAPosPV()) < kshortSelections.KShortMinDCAPosToPv) || (TMath::Abs(cand.kshortDCANegPV()) < kshortSelections.KShortMinDCANegToPv)) + if ((TMath::Abs(cand.kshortDCAPosPV()) < kshortSelections.kshortMinDCAPosToPv) || (TMath::Abs(cand.kshortDCANegPV()) < kshortSelections.kshortMinDCANegToPv)) return false; // Mass Selection fillSelHistos<10>(cand, PDG_t::kK0Short); - if (TMath::Abs(cand.kshortMass() - o2::constants::physics::MassK0Short) > kshortSelections.KShortWindow) + if (TMath::Abs(cand.kshortMass() - o2::constants::physics::MassK0Short) > kshortSelections.kshortWindow) return false; fillSelHistos<11>(cand, PDG_t::kK0Short); @@ -1174,23 +1174,23 @@ struct k892hadronphoton { // KStar specific selections // Rapidity if constexpr (requires { cand.kstarMCY(); }) { // MC - if (TMath::Abs(cand.kstarMCY()) > kstarSelections.KStarMaxRap) + if (TMath::Abs(cand.kstarMCY()) > kstarSelections.kstarMaxRap) return false; } else { // Real data - if (TMath::Abs(cand.kstarY()) > kstarSelections.KStarMaxRap) + if (TMath::Abs(cand.kstarY()) > kstarSelections.kstarMaxRap) return false; } // V0Pair Radius - if (cand.radius() > kstarSelections.KStarMaxRadius) + if (cand.radius() > kstarSelections.kstarMaxRadius) return false; // DCA V0Pair Daughters - if (cand.dcadaughters() > kstarSelections.KStarMaxDCADau) + if (cand.dcadaughters() > kstarSelections.kstarMaxDCADau) return false; // Opening Angle - if (cand.opAngle() > kstarSelections.KStarMaxOPAngle) + if (cand.opAngle() > kstarSelections.kstarMaxOPAngle) return false; return true; @@ -1211,7 +1211,7 @@ struct k892hadronphoton { for (const auto& coll : collisions) { // Event selection - if (!IsEventAccepted(coll, true)) + if (!isEventAccepted(coll, true)) continue; // KStars loop diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index 75c01abc59f..addc5435391 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -86,8 +86,8 @@ struct k892hadronphotonBkg { Configurable doEvtMixing{"doEvtMixing", false, "Mixed-event background"}; Configurable nMix{"nMix", 5, "Number of mixed events"}; Configurable deltaCollision{"deltaCollision", 25, "Min |Δ globalIndex| for mixing"}; - Configurable KStarMaxOPAngle{"KStarMaxOPAngle", 7.f, "Max opening angle (rad)"}; - Configurable KStarMaxRap{"KStarMaxRap", 0.5f, "Max |y(K*)|"}; + Configurable kstarMaxOPAngle{"kstarMaxOPAngle", 7.f, "Max opening angle (rad)"}; + Configurable kstarMaxRap{"kstarMaxRap", 0.5f, "Max |y(K*)|"}; Configurable nBkgRot{"nBkgRot", 3, "Rotations per pair (rotational bkg)"}; Configurable rotationalCut{"rotationalCut", 10, "theta band: [pi - pi/cut, pi + pi/cut]"}; } kstarBkgConfig; @@ -127,54 +127,54 @@ struct k892hadronphotonBkg { //// Photon criteria: struct : ConfigurableGroup { std::string prefix = "photonSelections"; // JSON group name - Configurable Gamma_MLThreshold{"Gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas"}; - Configurable Photonv0TypeSel{"Photonv0TypeSel", 7, "select on a certain V0 type (leave negative if no selection desired)"}; - Configurable PhotonMinDCADauToPv{"PhotonMinDCADauToPv", 0.0, "Min DCA daughter To PV (cm)"}; - Configurable PhotonMaxDCAV0Dau{"PhotonMaxDCAV0Dau", 3.5, "Max DCA V0 Daughters (cm)"}; - Configurable PhotonMinTPCCrossedRows{"PhotonMinTPCCrossedRows", 30, "Min daughter TPC Crossed Rows"}; - Configurable PhotonMinTPCNSigmas{"PhotonMinTPCNSigmas", -7, "Min TPC NSigmas for daughters"}; - Configurable PhotonMaxTPCNSigmas{"PhotonMaxTPCNSigmas", 7, "Max TPC NSigmas for daughters"}; - Configurable PhotonMinRapidity{"PhotonMinRapidity", -0.5, "v0 min rapidity"}; - Configurable PhotonMaxRapidity{"PhotonMaxRapidity", 0.5, "v0 max rapidity"}; - Configurable PhotonDauEtaMin{"PhotonDauEtaMin", -0.8, "Min pseudorapidity of daughter tracks"}; - Configurable PhotonDauEtaMax{"PhotonDauEtaMax", 0.8, "Max pseudorapidity of daughter tracks"}; - Configurable PhotonMinRadius{"PhotonMinRadius", 3.0, "Min photon conversion radius (cm)"}; - Configurable PhotonMaxRadius{"PhotonMaxRadius", 115, "Max photon conversion radius (cm)"}; - Configurable PhotonMinZ{"PhotonMinZ", -240, "Min photon conversion point z value (cm)"}; - Configurable PhotonMaxZ{"PhotonMaxZ", 240, "Max photon conversion point z value (cm)"}; - Configurable PhotonMaxQt{"PhotonMaxQt", 0.08, "Max photon qt value (AP plot) (GeV/c)"}; - Configurable PhotonMaxAlpha{"PhotonMaxAlpha", 1.0, "Max photon alpha absolute value (AP plot)"}; - Configurable PhotonMinV0cospa{"PhotonMinV0cospa", 0.80, "Min V0 CosPA"}; - Configurable PhotonMaxMass{"PhotonMaxMass", 0.10, "Max photon mass (GeV/c^{2})"}; - Configurable PhotonPhiMin1{"PhotonPhiMin1", -1, "Phi min value to reject photons, region 1 (leave negative if no selection desired)"}; - Configurable PhotonPhiMax1{"PhotonPhiMax1", -1, "Phi max value to reject photons, region 1 (leave negative if no selection desired)"}; - Configurable PhotonPhiMin2{"PhotonPhiMin2", -1, "Phi max value to reject photons, region 2 (leave negative if no selection desired)"}; - Configurable PhotonPhiMax2{"PhotonPhiMax2", -1, "Phi min value to reject photons, region 2 (leave negative if no selection desired)"}; + Configurable gamma_MLThreshold{"gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas"}; + Configurable photonv0TypeSel{"photonv0TypeSel", 7, "select on a certain V0 type (leave negative if no selection desired)"}; + Configurable photonMinDCADauToPv{"photonMinDCADauToPv", 0.0, "Min DCA daughter To PV (cm)"}; + Configurable photonMaxDCAV0Dau{"photonMaxDCAV0Dau", 3.5, "Max DCA V0 Daughters (cm)"}; + Configurable photonMinTPCCrossedRows{"photonMinTPCCrossedRows", 30, "Min daughter TPC Crossed Rows"}; + Configurable photonMinTPCNSigmas{"photonMinTPCNSigmas", -7, "Min TPC NSigmas for daughters"}; + Configurable photonMaxTPCNSigmas{"photonMaxTPCNSigmas", 7, "Max TPC NSigmas for daughters"}; + Configurable photonMinRapidity{"photonMinRapidity", -0.5, "v0 min rapidity"}; + Configurable photonMaxRapidity{"photonMaxRapidity", 0.5, "v0 max rapidity"}; + Configurable photonDauEtaMin{"photonDauEtaMin", -0.8, "Min pseudorapidity of daughter tracks"}; + Configurable photonDauEtaMax{"photonDauEtaMax", 0.8, "Max pseudorapidity of daughter tracks"}; + Configurable photonMinRadius{"photonMinRadius", 3.0, "Min photon conversion radius (cm)"}; + Configurable photonMaxRadius{"photonMaxRadius", 115, "Max photon conversion radius (cm)"}; + Configurable photonMinZ{"photonMinZ", -240, "Min photon conversion point z value (cm)"}; + Configurable photonMaxZ{"photonMaxZ", 240, "Max photon conversion point z value (cm)"}; + Configurable photonMaxQt{"photonMaxQt", 0.08, "Max photon qt value (AP plot) (GeV/c)"}; + Configurable photonMaxAlpha{"photonMaxAlpha", 1.0, "Max photon alpha absolute value (AP plot)"}; + Configurable photonMinV0cospa{"photonMinV0cospa", 0.80, "Min V0 CosPA"}; + Configurable photonMaxMass{"photonMaxMass", 0.10, "Max photon mass (GeV/c^{2})"}; + Configurable photonPhiMin1{"photonPhiMin1", -1, "Phi min value to reject photons, region 1 (leave negative if no selection desired)"}; + Configurable photonPhiMax1{"photonPhiMax1", -1, "Phi max value to reject photons, region 1 (leave negative if no selection desired)"}; + Configurable photonPhiMin2{"photonPhiMin2", -1, "Phi max value to reject photons, region 2 (leave negative if no selection desired)"}; + Configurable photonPhiMax2{"photonPhiMax2", -1, "Phi min value to reject photons, region 2 (leave negative if no selection desired)"}; } photonSelections; // KShort criteria: struct : ConfigurableGroup { std::string prefix = "kshortSelections"; // JSON group name - Configurable KShort_MLThreshold{"KShort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; - Configurable KShortMinDCANegToPv{"KShortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; - Configurable KShortMinDCAPosToPv{"KShortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; - Configurable KShortMaxDCAV0Dau{"KShortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; - Configurable KShortMinv0radius{"KShortMinv0radius", 0.0, "Min V0 radius (cm)"}; - Configurable KShortMaxv0radius{"KShortMaxv0radius", 40, "Max V0 radius (cm)"}; - Configurable KShortMinv0cospa{"KShortMinv0cospa", 0.95, "Min V0 CosPA"}; - Configurable KShortMaxLifeTime{"KShortMaxLifeTime", 20, "Max lifetime"}; - Configurable KShortWindow{"KShortWindow", 0.015, "Mass window around expected (in GeV/c2). Leave negative to disable"}; - Configurable KShortMinRapidity{"KShortMinRapidity", -0.5, "v0 min rapidity"}; - Configurable KShortMaxRapidity{"KShortMaxRapidity", 0.5, "v0 max rapidity"}; - Configurable KShortDauEtaMin{"KShortDauEtaMin", -0.8, "Min pseudorapidity of daughter tracks"}; - Configurable KShortDauEtaMax{"KShortDauEtaMax", 0.8, "Max pseudorapidity of daughter tracks"}; - Configurable KShortMinZ{"KShortMinZ", -240, "Min kshort decay point z value (cm)"}; - Configurable KShortMaxZ{"KShortMaxZ", 240, "Max kshort decay point z value (cm)"}; - Configurable KShortMinTPCCrossedRows{"KShortMinTPCCrossedRows", 50, "Min daughter TPC Crossed Rows"}; - Configurable KShortMinITSclusters{"KShortMinITSclusters", 1, "minimum ITS clusters"}; - Configurable KShortRejectPosITSafterburner{"KShortRejectPosITSafterburner", false, "reject positive track formed out of afterburner ITS tracks"}; - Configurable KShortRejectNegITSafterburner{"KShortRejectNegITSafterburner", false, "reject negative track formed out of afterburner ITS tracks"}; - Configurable KShortArmenterosCoefficient{"KShortArmenterosCoefficient", 0.2, "Armenteros-Podolanski coefficient to reject lambdas"}; + Configurable kshort_MLThreshold{"KShort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; + Configurable kshortMinDCANegToPv{"KShortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; + Configurable kshortMinDCAPosToPv{"KShortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; + Configurable kshortMaxDCAV0Dau{"KShortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; + Configurable kshortMinv0radius{"KShortMinv0radius", 0.0, "Min V0 radius (cm)"}; + Configurable kshortMaxv0radius{"KShortMaxv0radius", 40, "Max V0 radius (cm)"}; + Configurable kshortMinv0cospa{"KShortMinv0cospa", 0.95, "Min V0 CosPA"}; + Configurable kshortMaxLifeTime{"KShortMaxLifeTime", 20, "Max lifetime"}; + Configurable kshortWindow{"KShortWindow", 0.015, "Mass window around expected (in GeV/c2). Leave negative to disable"}; + Configurable kshortMinRapidity{"KShortMinRapidity", -0.5, "v0 min rapidity"}; + Configurable kshortMaxRapidity{"KShortMaxRapidity", 0.5, "v0 max rapidity"}; + Configurable kshortDauEtaMin{"KShortDauEtaMin", -0.8, "Min pseudorapidity of daughter tracks"}; + Configurable kshortDauEtaMax{"KShortDauEtaMax", 0.8, "Max pseudorapidity of daughter tracks"}; + Configurable kshortMinZ{"KShortMinZ", -240, "Min kshort decay point z value (cm)"}; + Configurable kshortMaxZ{"KShortMaxZ", 240, "Max kshort decay point z value (cm)"}; + Configurable kshortMinTPCCrossedRows{"KShortMinTPCCrossedRows", 50, "Min daughter TPC Crossed Rows"}; + Configurable kshortMinITSclusters{"KShortMinITSclusters", 1, "minimum ITS clusters"}; + Configurable kshortRejectPosITSafterburner{"KShortRejectPosITSafterburner", false, "reject positive track formed out of afterburner ITS tracks"}; + Configurable kshortRejectNegITSafterburner{"KShortRejectNegITSafterburner", false, "reject negative track formed out of afterburner ITS tracks"}; + Configurable kshortArmenterosCoefficient{"KShortArmenterosCoefficient", 0.2, "Armenteros-Podolanski coefficient to reject lambdas"}; } kshortSelections; struct : ConfigurableGroup { @@ -390,65 +390,65 @@ struct k892hadronphotonBkg { bool processPhotonCandidate(TV0Object const& gamma) { // V0 type selection - if (gamma.v0Type() != photonSelections.Photonv0TypeSel && photonSelections.Photonv0TypeSel > -1) + if (gamma.v0Type() != photonSelections.photonv0TypeSel && photonSelections.photonv0TypeSel > -1) return false; float PhotonY = RecoDecay::y(std::array{gamma.px(), gamma.py(), gamma.pz()}, o2::constants::physics::MassGamma); if (useMLScores) { - if (gamma.gammaBDTScore() <= photonSelections.Gamma_MLThreshold) + if (gamma.gammaBDTScore() <= photonSelections.gamma_MLThreshold) return false; } else { // Standard selection // Gamma basic selection criteria: - if ((gamma.mGamma() < 0) || (gamma.mGamma() > photonSelections.PhotonMaxMass)) + if ((gamma.mGamma() < 0) || (gamma.mGamma() > photonSelections.photonMaxMass)) return false; - if ((PhotonY < photonSelections.PhotonMinRapidity) || (PhotonY > photonSelections.PhotonMaxRapidity)) + if ((PhotonY < photonSelections.photonMinRapidity) || (PhotonY > photonSelections.photonMaxRapidity)) return false; - if (gamma.negativeeta() < photonSelections.PhotonDauEtaMin || gamma.negativeeta() > photonSelections.PhotonDauEtaMax) + if (gamma.negativeeta() < photonSelections.photonDauEtaMin || gamma.negativeeta() > photonSelections.photonDauEtaMax) return false; - if (gamma.positiveeta() < photonSelections.PhotonDauEtaMin || gamma.positiveeta() > photonSelections.PhotonDauEtaMax) + if (gamma.positiveeta() < photonSelections.photonDauEtaMin || gamma.positiveeta() > photonSelections.photonDauEtaMax) return false; - if ((TMath::Abs(gamma.dcapostopv()) < photonSelections.PhotonMinDCADauToPv) || (TMath::Abs(gamma.dcanegtopv()) < photonSelections.PhotonMinDCADauToPv)) + if ((TMath::Abs(gamma.dcapostopv()) < photonSelections.photonMinDCADauToPv) || (TMath::Abs(gamma.dcanegtopv()) < photonSelections.photonMinDCADauToPv)) return false; - if (TMath::Abs(gamma.dcaV0daughters()) > photonSelections.PhotonMaxDCAV0Dau) + if (TMath::Abs(gamma.dcaV0daughters()) > photonSelections.photonMaxDCAV0Dau) return false; - if ((gamma.v0radius() < photonSelections.PhotonMinRadius) || (gamma.v0radius() > photonSelections.PhotonMaxRadius)) + if ((gamma.v0radius() < photonSelections.photonMinRadius) || (gamma.v0radius() > photonSelections.photonMaxRadius)) return false; - if ((gamma.z() < photonSelections.PhotonMinZ) || (gamma.z() > photonSelections.PhotonMaxZ)) + if ((gamma.z() < photonSelections.photonMinZ) || (gamma.z() > photonSelections.photonMaxZ)) return false; - if (gamma.v0cosPA() < photonSelections.PhotonMinV0cospa) + if (gamma.v0cosPA() < photonSelections.photonMinV0cospa) return false; float PhotonPhi = RecoDecay::phi(gamma.px(), gamma.py()); - if ((((PhotonPhi > photonSelections.PhotonPhiMin1) && (PhotonPhi < photonSelections.PhotonPhiMax1)) || ((PhotonPhi > photonSelections.PhotonPhiMin2) && (PhotonPhi < photonSelections.PhotonPhiMax2))) && ((photonSelections.PhotonPhiMin1 != -1) && (photonSelections.PhotonPhiMax1 != -1) && (photonSelections.PhotonPhiMin2 != -1) && (photonSelections.PhotonPhiMax2 != -1))) + if ((((PhotonPhi > photonSelections.photonPhiMin1) && (PhotonPhi < photonSelections.photonPhiMax1)) || ((PhotonPhi > photonSelections.photonPhiMin2) && (PhotonPhi < photonSelections.photonPhiMax2))) && ((photonSelections.photonPhiMin1 != -1) && (photonSelections.photonPhiMax1 != -1) && (photonSelections.photonPhiMin2 != -1) && (photonSelections.photonPhiMax2 != -1))) return false; - if (gamma.qtarm() > photonSelections.PhotonMaxQt) + if (gamma.qtarm() > photonSelections.photonMaxQt) return false; - if (TMath::Abs(gamma.alpha()) > photonSelections.PhotonMaxAlpha) + if (TMath::Abs(gamma.alpha()) > photonSelections.photonMaxAlpha) return false; auto posTrackGamma = gamma.template posTrackExtra_as(); auto negTrackGamma = gamma.template negTrackExtra_as(); - if ((posTrackGamma.tpcCrossedRows() < photonSelections.PhotonMinTPCCrossedRows) || (negTrackGamma.tpcCrossedRows() < photonSelections.PhotonMinTPCCrossedRows)) + if ((posTrackGamma.tpcCrossedRows() < photonSelections.photonMinTPCCrossedRows) || (negTrackGamma.tpcCrossedRows() < photonSelections.photonMinTPCCrossedRows)) return false; - if (((posTrackGamma.tpcNSigmaEl() < photonSelections.PhotonMinTPCNSigmas) || (posTrackGamma.tpcNSigmaEl() > photonSelections.PhotonMaxTPCNSigmas))) + if (((posTrackGamma.tpcNSigmaEl() < photonSelections.photonMinTPCNSigmas) || (posTrackGamma.tpcNSigmaEl() > photonSelections.photonMaxTPCNSigmas))) return false; - if (((negTrackGamma.tpcNSigmaEl() < photonSelections.PhotonMinTPCNSigmas) || (negTrackGamma.tpcNSigmaEl() > photonSelections.PhotonMaxTPCNSigmas))) + if (((negTrackGamma.tpcNSigmaEl() < photonSelections.photonMinTPCNSigmas) || (negTrackGamma.tpcNSigmaEl() > photonSelections.photonMaxTPCNSigmas))) return false; } @@ -470,53 +470,53 @@ struct k892hadronphotonBkg { } else { // KShort basic selection criteria: - if ((TMath::Abs(kshort.mK0Short() - o2::constants::physics::MassK0Short) > kshortSelections.KShortWindow) && kshortSelections.KShortWindow > 0) + if ((TMath::Abs(kshort.mK0Short() - o2::constants::physics::MassK0Short) > kshortSelections.kshortWindow) && kshortSelections.kshortWindow > 0) return false; - if ((kshort.yK0Short() < kshortSelections.KShortMinRapidity) || (kshort.yK0Short() > kshortSelections.KShortMaxRapidity)) + if ((kshort.yK0Short() < kshortSelections.kshortMinRapidity) || (kshort.yK0Short() > kshortSelections.kshortMaxRapidity)) return false; - if ((kshort.negativeeta() < kshortSelections.KShortDauEtaMin) || (kshort.negativeeta() > kshortSelections.KShortDauEtaMax)) + if ((kshort.negativeeta() < kshortSelections.kshortDauEtaMin) || (kshort.negativeeta() > kshortSelections.kshortDauEtaMax)) return false; - if ((kshort.positiveeta() < kshortSelections.KShortDauEtaMin) || (kshort.positiveeta() > kshortSelections.KShortDauEtaMax)) + if ((kshort.positiveeta() < kshortSelections.kshortDauEtaMin) || (kshort.positiveeta() > kshortSelections.kshortDauEtaMax)) return false; - if ((TMath::Abs(kshort.dcapostopv()) < kshortSelections.KShortMinDCAPosToPv) || (TMath::Abs(kshort.dcanegtopv()) < kshortSelections.KShortMinDCANegToPv)) + if ((TMath::Abs(kshort.dcapostopv()) < kshortSelections.kshortMinDCAPosToPv) || (TMath::Abs(kshort.dcanegtopv()) < kshortSelections.kshortMinDCANegToPv)) return false; - if ((kshort.v0radius() < kshortSelections.KShortMinv0radius) || (kshort.v0radius() > kshortSelections.KShortMaxv0radius)) + if ((kshort.v0radius() < kshortSelections.kshortMinv0radius) || (kshort.v0radius() > kshortSelections.kshortMaxv0radius)) return false; - if ((kshort.z() < kshortSelections.KShortMinZ) || (kshort.z() > kshortSelections.KShortMaxZ)) + if ((kshort.z() < kshortSelections.kshortMinZ) || (kshort.z() > kshortSelections.kshortMaxZ)) return false; - if (TMath::Abs(kshort.dcaV0daughters()) > kshortSelections.KShortMaxDCAV0Dau) + if (TMath::Abs(kshort.dcaV0daughters()) > kshortSelections.kshortMaxDCAV0Dau) return false; - if (kshort.qtarm() < kshortSelections.KShortArmenterosCoefficient * TMath::Abs(kshort.alpha())) + if (kshort.qtarm() < kshortSelections.kshortArmenterosCoefficient * TMath::Abs(kshort.alpha())) return false; - if (kshort.v0cosPA() < kshortSelections.KShortMinv0cospa) + if (kshort.v0cosPA() < kshortSelections.kshortMinv0cospa) return false; auto posTrackKShort = kshort.template posTrackExtra_as(); auto negTrackKShort = kshort.template negTrackExtra_as(); - if ((posTrackKShort.tpcCrossedRows() < kshortSelections.KShortMinTPCCrossedRows) || (negTrackKShort.tpcCrossedRows() < kshortSelections.KShortMinTPCCrossedRows)) + if ((posTrackKShort.tpcCrossedRows() < kshortSelections.kshortMinTPCCrossedRows) || (negTrackKShort.tpcCrossedRows() < kshortSelections.kshortMinTPCCrossedRows)) return false; // MinITSCls bool posIsFromAfterburner = posTrackKShort.itsChi2PerNcl() < 0; bool negIsFromAfterburner = negTrackKShort.itsChi2PerNcl() < 0; - if (posTrackKShort.itsNCls() < kshortSelections.KShortMinITSclusters && (!kshortSelections.KShortRejectPosITSafterburner || posIsFromAfterburner)) + if (posTrackKShort.itsNCls() < kshortSelections.kshortMinITSclusters && (!kshortSelections.kshortRejectPosITSafterburner || posIsFromAfterburner)) return false; - if (negTrackKShort.itsNCls() < kshortSelections.KShortMinITSclusters && (!kshortSelections.KShortRejectNegITSafterburner || negIsFromAfterburner)) + if (negTrackKShort.itsNCls() < kshortSelections.kshortMinITSclusters && (!kshortSelections.kshortRejectNegITSafterburner || negIsFromAfterburner)) return false; float fKShortLifeTime = kshort.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short; - if (fKShortLifeTime > kshortSelections.KShortMaxLifeTime) + if (fKShortLifeTime > kshortSelections.kshortMaxLifeTime) return false; } return true; @@ -558,7 +558,7 @@ struct k892hadronphotonBkg { static_cast(kstar.Py()), static_cast(kstar.Pz())}, o2::constants::physics::MassK0Star892); - if (std::abs(rapidity) > kstarBkgConfig.KStarMaxRap) + if (std::abs(rapidity) > kstarBkgConfig.kstarMaxRap) continue; // Opening angle between photon and rotated K0s (QA only, not used as a cut) @@ -682,9 +682,9 @@ struct k892hadronphotonBkg { static_cast(FourMomKStar.Pz())}, o2::constants::physics::MassK0Star892); - if (openAngle > kstarBkgConfig.KStarMaxOPAngle) + if (openAngle > kstarBkgConfig.kstarMaxOPAngle) continue; - if (std::abs(rapidity) > kstarBkgConfig.KStarMaxRap) + if (std::abs(rapidity) > kstarBkgConfig.kstarMaxRap) continue; histos.fill(HIST("KStarBkg/h2dMixedKStarMassVsPt"), mass, pt); @@ -729,9 +729,9 @@ struct k892hadronphotonBkg { static_cast(FourMomKStar.Pz())}, o2::constants::physics::MassK0Star892); - if (openAngle > kstarBkgConfig.KStarMaxOPAngle) + if (openAngle > kstarBkgConfig.kstarMaxOPAngle) continue; - if (std::abs(rapidity) > kstarBkgConfig.KStarMaxRap) + if (std::abs(rapidity) > kstarBkgConfig.kstarMaxRap) continue; histos.fill(HIST("KStarBkg/h2dMixedKStarMassVsPt"), mass, pt); From c9a4d8c7440b5c24541badac667f0ac54f47aa05 Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Fri, 19 Jun 2026 11:33:56 +0200 Subject: [PATCH 07/13] additional o2linter fixes --- .../Tasks/Resonances/k892hadronphotonBkg.cxx | 40 +++++++++---------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index addc5435391..57349131b3f 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -155,26 +155,26 @@ struct k892hadronphotonBkg { // KShort criteria: struct : ConfigurableGroup { std::string prefix = "kshortSelections"; // JSON group name - Configurable kshort_MLThreshold{"KShort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; - Configurable kshortMinDCANegToPv{"KShortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; - Configurable kshortMinDCAPosToPv{"KShortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; - Configurable kshortMaxDCAV0Dau{"KShortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; - Configurable kshortMinv0radius{"KShortMinv0radius", 0.0, "Min V0 radius (cm)"}; - Configurable kshortMaxv0radius{"KShortMaxv0radius", 40, "Max V0 radius (cm)"}; - Configurable kshortMinv0cospa{"KShortMinv0cospa", 0.95, "Min V0 CosPA"}; - Configurable kshortMaxLifeTime{"KShortMaxLifeTime", 20, "Max lifetime"}; - Configurable kshortWindow{"KShortWindow", 0.015, "Mass window around expected (in GeV/c2). Leave negative to disable"}; - Configurable kshortMinRapidity{"KShortMinRapidity", -0.5, "v0 min rapidity"}; - Configurable kshortMaxRapidity{"KShortMaxRapidity", 0.5, "v0 max rapidity"}; - Configurable kshortDauEtaMin{"KShortDauEtaMin", -0.8, "Min pseudorapidity of daughter tracks"}; - Configurable kshortDauEtaMax{"KShortDauEtaMax", 0.8, "Max pseudorapidity of daughter tracks"}; - Configurable kshortMinZ{"KShortMinZ", -240, "Min kshort decay point z value (cm)"}; - Configurable kshortMaxZ{"KShortMaxZ", 240, "Max kshort decay point z value (cm)"}; - Configurable kshortMinTPCCrossedRows{"KShortMinTPCCrossedRows", 50, "Min daughter TPC Crossed Rows"}; - Configurable kshortMinITSclusters{"KShortMinITSclusters", 1, "minimum ITS clusters"}; - Configurable kshortRejectPosITSafterburner{"KShortRejectPosITSafterburner", false, "reject positive track formed out of afterburner ITS tracks"}; - Configurable kshortRejectNegITSafterburner{"KShortRejectNegITSafterburner", false, "reject negative track formed out of afterburner ITS tracks"}; - Configurable kshortArmenterosCoefficient{"KShortArmenterosCoefficient", 0.2, "Armenteros-Podolanski coefficient to reject lambdas"}; + Configurable kshort_MLThreshold{"kshort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; + Configurable kshortMinDCANegToPv{"kshortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; + Configurable kshortMinDCAPosToPv{"kshortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; + Configurable kshortMaxDCAV0Dau{"kshortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; + Configurable kshortMinv0radius{"kshortMinv0radius", 0.0, "Min V0 radius (cm)"}; + Configurable kshortMaxv0radius{"kshortMaxv0radius", 40, "Max V0 radius (cm)"}; + Configurable kshortMinv0cospa{"kshortMinv0cospa", 0.95, "Min V0 CosPA"}; + Configurable kshortMaxLifeTime{"kshortMaxLifeTime", 20, "Max lifetime"}; + Configurable kshortWindow{"kshortWindow", 0.015, "Mass window around expected (in GeV/c2). Leave negative to disable"}; + Configurable kshortMinRapidity{"kshortMinRapidity", -0.5, "v0 min rapidity"}; + Configurable kshortMaxRapidity{"kshortMaxRapidity", 0.5, "v0 max rapidity"}; + Configurable kshortDauEtaMin{"kshortDauEtaMin", -0.8, "Min pseudorapidity of daughter tracks"}; + Configurable kshortDauEtaMax{"kshortDauEtaMax", 0.8, "Max pseudorapidity of daughter tracks"}; + Configurable kshortMinZ{"kshortMinZ", -240, "Min kshort decay point z value (cm)"}; + Configurable kshortMaxZ{"kshortMaxZ", 240, "Max kshort decay point z value (cm)"}; + Configurable kshortMinTPCCrossedRows{"kshortMinTPCCrossedRows", 50, "Min daughter TPC Crossed Rows"}; + Configurable kshortMinITSclusters{"kshortMinITSclusters", 1, "minimum ITS clusters"}; + Configurable kshortRejectPosITSafterburner{"kshortRejectPosITSafterburner", false, "reject positive track formed out of afterburner ITS tracks"}; + Configurable kshortRejectNegITSafterburner{"kshortRejectNegITSafterburner", false, "reject negative track formed out of afterburner ITS tracks"}; + Configurable kshortArmenterosCoefficient{"kshortArmenterosCoefficient", 0.2, "Armenteros-Podolanski coefficient to reject lambdas"}; } kshortSelections; struct : ConfigurableGroup { From 90ee3f25dcd1ed03ccac31b585dbebfbd70761ca Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Fri, 19 Jun 2026 16:04:52 +0200 Subject: [PATCH 08/13] More o2linter fixes --- PWGLF/Tasks/Resonances/k892hadronphoton.cxx | 36 +++++----- .../Tasks/Resonances/k892hadronphotonBkg.cxx | 66 +++++++++---------- iwyu.out | 1 + 3 files changed, 52 insertions(+), 51 deletions(-) create mode 100644 iwyu.out diff --git a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx index da9f968009b..7bebeae517c 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx @@ -60,12 +60,12 @@ using namespace o2::framework::expressions; using KStars = soa::Join; using MCKStars = soa::Join; -static const std::vector PhotonSels = {"NoSel", "V0Type", "DCADauToPV", +static const std::vector photonSels = {"NoSel", "V0Type", "DCADauToPV", "DCADau", "DauTPCCR", "TPCNSigmaEl", "V0pT", "Y", "V0Radius", "RZCut", "Armenteros", "CosPA", "PsiPair", "Phi", "Mass"}; -static const std::vector KShortSels = {"NoSel", "V0Radius", "DCADau", "Armenteros", +static const std::vector kshortSels = {"NoSel", "V0Radius", "DCADau", "Armenteros", "CosPA", "Y", "TPCCR", "DauITSCls", "Lifetime", "TPCTOFPID", "DCADauToPV", "Mass"}; @@ -121,7 +121,7 @@ struct k892hadronphoton { } eventSelections; // generated - Configurable mc_keepOnlyFromGenerator{"mc_keepOnlyFromGenerator", true, "if true, consider only particles from generator to calculate efficiency."}; + Configurable mcKeepOnlyFromGenerator{"mcKeepOnlyFromGenerator", true, "if true, consider only particles from generator to calculate efficiency."}; // QA Configurable fillBkgQAhistos{"fillBkgQAhistos", false, "if true, fill MC QA histograms for Bkg study. Only works with MC."}; @@ -134,7 +134,7 @@ struct k892hadronphoton { //// K0Short criteria: struct : ConfigurableGroup { - Configurable kshort_MLThreshold{"kshort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; + Configurable kshortMLThreshold{"kshortMLThreshold", 0.1, "Decision Threshold value to select kshorts"}; Configurable kshortMinDCANegToPv{"kshortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; Configurable kshortMinDCAPosToPv{"kshortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; Configurable kshortMaxDCAV0Dau{"kshortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; @@ -162,7 +162,7 @@ struct k892hadronphoton { //// Photon criteria: struct : ConfigurableGroup { - Configurable gamma_MLThreshold{"gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas"}; + Configurable gammaMLThreshold{"gammaMLThreshold", 0.1, "Decision Threshold value to select gammas"}; Configurable photonv0TypeSel{"photonv0TypeSel", 7, "select on a certain V0 type (leave negative if no selection desired)"}; Configurable photonMinDCADauToPv{"photonMinDCADauToPv", 0.0, "Min DCA daughter To PV (cm)"}; Configurable photonMaxDCAV0Dau{"photonMaxDCAV0Dau", 3.5, "Max DCA V0 Daughters (cm)"}; @@ -408,16 +408,16 @@ struct k892hadronphoton { histos.add("Selection/Photon/hCandidateSel", "hCandidateSel", kTH1D, {axisCandSel}); histos.add("Selection/KShort/hCandidateSel", "hCandidateSel", kTH1D, {axisCandSel}); - for (size_t i = 0; i < PhotonSels.size(); ++i) { - const auto& sel = PhotonSels[i]; + for (size_t i = 0; i < photonSels.size(); ++i) { + const auto& sel = photonSels[i]; histos.add(Form("Selection/Photon/h2d%s", sel.c_str()), ("h2d" + sel).c_str(), kTH2D, {axisPt, axisPhotonMass}); histos.get(HIST("Selection/Photon/hCandidateSel"))->GetXaxis()->SetBinLabel(i + 1, sel.c_str()); histos.add(Form("Selection/KStar/h2dPhoton%s", sel.c_str()), ("h2dPhoton" + sel).c_str(), kTH2D, {axisPt, axisKStarMass}); } - for (size_t i = 0; i < KShortSels.size(); ++i) { - const auto& sel = KShortSels[i]; + for (size_t i = 0; i < kshortSels.size(); ++i) { + const auto& sel = kshortSels[i]; histos.add(Form("Selection/KShort/h2d%s", sel.c_str()), ("h2d" + sel).c_str(), kTH2D, {axisPt, axisKShortMass}); histos.get(HIST("Selection/KShort/hCandidateSel"))->GetXaxis()->SetBinLabel(i + 1, sel.c_str()); @@ -691,7 +691,7 @@ struct k892hadronphoton { continue; // Selection on the source (generator/transport) - if (!genParticle.producedByGenerator() && mc_keepOnlyFromGenerator) + if (!genParticle.producedByGenerator() && mcKeepOnlyFromGenerator) continue; // Select corresponding mc collision && Basic event selection @@ -988,28 +988,28 @@ struct k892hadronphoton { void fillSelHistos(TKStarObject const& kstar, int PDGRequired) { - static constexpr std::string_view PhotonSelsLocal[] = {"NoSel", "V0Type", "DCADauToPV", + static constexpr std::string_view photonSelsLocal[] = {"NoSel", "V0Type", "DCADauToPV", "DCADau", "DauTPCCR", "TPCNSigmaEl", "V0pT", "Y", "V0Radius", "RZCut", "Armenteros", "CosPA", "PsiPair", "Phi", "Mass"}; - static constexpr std::string_view KShortSelsLocal[] = {"NoSel", "V0Radius", "DCADau", "Armenteros", + static constexpr std::string_view kshortSelsLocal[] = {"NoSel", "V0Radius", "DCADau", "Armenteros", "CosPA", "Y", "TPCCR", "DauITSCls", "Lifetime", "TPCTOFPID", "DCADauToPV", "Mass"}; if (std::abs(PDGRequired) == PDG_t::kGamma) { - if constexpr (selection_index >= 0 && selection_index < static_cast(std::size(PhotonSelsLocal))) { + if constexpr (selection_index >= 0 && selection_index < static_cast(std::size(photonSelsLocal))) { histos.fill(HIST("Selection/Photon/hCandidateSel"), selection_index); - histos.fill(HIST("Selection/Photon/h2d") + HIST(PhotonSelsLocal[selection_index]), kstar.photonPt(), kstar.photonMass()); - histos.fill(HIST("Selection/KStar/h2dPhoton") + HIST(PhotonSelsLocal[selection_index]), kstar.pt(), kstar.kstarMass()); + histos.fill(HIST("Selection/Photon/h2d") + HIST(photonSelsLocal[selection_index]), kstar.photonPt(), kstar.photonMass()); + histos.fill(HIST("Selection/KStar/h2dPhoton") + HIST(photonSelsLocal[selection_index]), kstar.pt(), kstar.kstarMass()); } } if (std::abs(PDGRequired) == PDG_t::kK0Short) { - if constexpr (selection_index >= 0 && selection_index < static_cast(std::size(KShortSelsLocal))) { + if constexpr (selection_index >= 0 && selection_index < static_cast(std::size(kshortSelsLocal))) { histos.fill(HIST("Selection/KShort/hCandidateSel"), selection_index); - histos.fill(HIST("Selection/KShort/h2d") + HIST(KShortSelsLocal[selection_index]), kstar.kshortPt(), kstar.kshortMass()); - histos.fill(HIST("Selection/KStar/h2dKShort") + HIST(KShortSelsLocal[selection_index]), kstar.pt(), kstar.kstarMass()); + histos.fill(HIST("Selection/KShort/h2d") + HIST(kshortSelsLocal[selection_index]), kstar.kshortPt(), kstar.kshortMass()); + histos.fill(HIST("Selection/KStar/h2dKShort") + HIST(kshortSelsLocal[selection_index]), kstar.pt(), kstar.kstarMass()); } } } diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index 57349131b3f..9968918cf54 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -20,7 +20,6 @@ // oussama.benchikhi@cern.ch // -#include "PWGLF/DataModel/LFSigmaTables.h" #include "PWGLF/DataModel/LFStrangenessMLTables.h" #include "PWGLF/DataModel/LFStrangenessPIDTables.h" #include "PWGLF/DataModel/LFStrangenessTables.h" @@ -28,6 +27,7 @@ #include "Common/CCDB/EventSelectionParams.h" #include "Common/CCDB/ctpRateFetcher.h" #include "Common/Core/RecoDecay.h" +#include "Common/DataModel/Centrality.h" #include #include @@ -42,11 +42,10 @@ #include #include #include +#include "Framework/BinningPolicy.h" -#include #include #include -#include #include #include @@ -54,6 +53,7 @@ #include #include #include +#include using namespace o2; using namespace o2::framework; @@ -127,7 +127,7 @@ struct k892hadronphotonBkg { //// Photon criteria: struct : ConfigurableGroup { std::string prefix = "photonSelections"; // JSON group name - Configurable gamma_MLThreshold{"gamma_MLThreshold", 0.1, "Decision Threshold value to select gammas"}; + Configurable gammaMLThreshold{"gammaMLThreshold", 0.1, "Decision Threshold value to select gammas"}; Configurable photonv0TypeSel{"photonv0TypeSel", 7, "select on a certain V0 type (leave negative if no selection desired)"}; Configurable photonMinDCADauToPv{"photonMinDCADauToPv", 0.0, "Min DCA daughter To PV (cm)"}; Configurable photonMaxDCAV0Dau{"photonMaxDCAV0Dau", 3.5, "Max DCA V0 Daughters (cm)"}; @@ -155,7 +155,7 @@ struct k892hadronphotonBkg { // KShort criteria: struct : ConfigurableGroup { std::string prefix = "kshortSelections"; // JSON group name - Configurable kshort_MLThreshold{"kshort_MLThreshold", 0.1, "Decision Threshold value to select kshorts"}; + Configurable kshortMLThreshold{"kshortMLThreshold", 0.1, "Decision Threshold value to select kshorts"}; Configurable kshortMinDCANegToPv{"kshortMinDCANegToPv", .05, "min DCA Neg To PV (cm)"}; Configurable kshortMinDCAPosToPv{"kshortMinDCAPosToPv", .05, "min DCA Pos To PV (cm)"}; Configurable kshortMaxDCAV0Dau{"kshortMaxDCAV0Dau", 2.5, "Max DCA V0 Daughters (cm)"}; @@ -249,7 +249,7 @@ struct k892hadronphotonBkg { //_______________________________________________ // Event selection (identical to the builder) template - bool IsEventAccepted(TCollision const& collision, bool fillHists) + bool isEventAccepted(TCollision const& collision, bool fillHists) { if (fillHists) histos.fill(HIST("hEventSelection"), 0. /* all collisions */); @@ -393,10 +393,10 @@ struct k892hadronphotonBkg { if (gamma.v0Type() != photonSelections.photonv0TypeSel && photonSelections.photonv0TypeSel > -1) return false; - float PhotonY = RecoDecay::y(std::array{gamma.px(), gamma.py(), gamma.pz()}, o2::constants::physics::MassGamma); + float photonY = RecoDecay::y(std::array{gamma.px(), gamma.py(), gamma.pz()}, o2::constants::physics::MassGamma); if (useMLScores) { - if (gamma.gammaBDTScore() <= photonSelections.gamma_MLThreshold) + if (gamma.gammaBDTScore() <= photonSelections.gammaMLThreshold) return false; } else { @@ -405,7 +405,7 @@ struct k892hadronphotonBkg { if ((gamma.mGamma() < 0) || (gamma.mGamma() > photonSelections.photonMaxMass)) return false; - if ((PhotonY < photonSelections.photonMinRapidity) || (PhotonY > photonSelections.photonMaxRapidity)) + if ((photonY < photonSelections.photonMinRapidity) || (photonY > photonSelections.photonMaxRapidity)) return false; if (gamma.negativeeta() < photonSelections.photonDauEtaMin || gamma.negativeeta() > photonSelections.photonDauEtaMax) @@ -429,8 +429,8 @@ struct k892hadronphotonBkg { if (gamma.v0cosPA() < photonSelections.photonMinV0cospa) return false; - float PhotonPhi = RecoDecay::phi(gamma.px(), gamma.py()); - if ((((PhotonPhi > photonSelections.photonPhiMin1) && (PhotonPhi < photonSelections.photonPhiMax1)) || ((PhotonPhi > photonSelections.photonPhiMin2) && (PhotonPhi < photonSelections.photonPhiMax2))) && ((photonSelections.photonPhiMin1 != -1) && (photonSelections.photonPhiMax1 != -1) && (photonSelections.photonPhiMin2 != -1) && (photonSelections.photonPhiMax2 != -1))) + float photonPhi = RecoDecay::phi(gamma.px(), gamma.py()); + if ((((photonPhi > photonSelections.photonPhiMin1) && (photonPhi < photonSelections.photonPhiMax1)) || ((photonPhi > photonSelections.photonPhiMin2) && (photonPhi < photonSelections.photonPhiMax2))) && ((photonSelections.photonPhiMin1 != -1) && (photonSelections.photonPhiMax1 != -1) && (photonSelections.photonPhiMin2 != -1) && (photonSelections.photonPhiMax2 != -1))) return false; if (gamma.qtarm() > photonSelections.photonMaxQt) @@ -465,7 +465,7 @@ struct k892hadronphotonBkg { return false; if (useMLScores) { - // if (kshort.k0ShortBDTScore() <= kshortSelections.KShort_MLThreshold) + // if (kshort.k0ShortBDTScore() <= kshortSelections.kshortMLThreshold) return false; } else { @@ -600,7 +600,7 @@ struct k892hadronphotonBkg { // ── Pass 1: populate pools using single-particle selections ── for (const auto& coll : collisions) { - if (eventSelections.fUseEventSelection && !IsEventAccepted(coll, true)) + if (eventSelections.fUseEventSelection && !isEventAccepted(coll, true)) continue; for (size_t i = 0; i < v0grouped[coll.globalIndex()].size(); i++) { @@ -654,7 +654,7 @@ struct k892hadronphotonBkg { for (int kIdx : kshorts1) { auto kshort = fullV0s.rawIteratorAt(kIdx); float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); - ROOT::Math::PxPyPzEVector FourMomKShort( + ROOT::Math::PxPyPzEVector fourMomKShort( kshort.px(), kshort.py(), kshort.pz(), std::sqrt(kP * kP + o2::constants::physics::MassK0Short * @@ -663,23 +663,23 @@ struct k892hadronphotonBkg { for (int pIdx : photons2) { auto photon = fullV0s.rawIteratorAt(pIdx); float pP = std::hypot(photon.px(), photon.py(), photon.pz()); - ROOT::Math::PxPyPzEVector FourMomPhoton( + ROOT::Math::PxPyPzEVector fourMomPhoton( photon.px(), photon.py(), photon.pz(), pP); - auto FourMomKStar = FourMomPhoton + FourMomKShort; + auto fourMomKStar = fourMomPhoton + fourMomKShort; - double cosOA = FourMomPhoton.Vect().Dot(FourMomKShort.Vect()) / - (FourMomPhoton.P() * FourMomKShort.P()); + double cosOA = fourMomPhoton.Vect().Dot(fourMomKShort.Vect()) / + (fourMomPhoton.P() * fourMomKShort.P()); double openAngle = std::acos(cosOA); - float mass = FourMomKStar.M(); - float pt = FourMomKStar.Pt(); + float mass = fourMomKStar.M(); + float pt = fourMomKStar.Pt(); // Rapidity computed under the K*(892) mass hypothesis (NOT the actual pair // invariant mass) to match the same-event rotational background and the // buildKStar signal selection, so the rapidity acceptance is identical for // signal and all backgrounds. - float rapidity = RecoDecay::y(std::array{static_cast(FourMomKStar.Px()), - static_cast(FourMomKStar.Py()), - static_cast(FourMomKStar.Pz())}, + float rapidity = RecoDecay::y(std::array{static_cast(fourMomKStar.Px()), + static_cast(fourMomKStar.Py()), + static_cast(fourMomKStar.Pz())}, o2::constants::physics::MassK0Star892); if (openAngle > kstarBkgConfig.kstarMaxOPAngle) @@ -701,32 +701,32 @@ struct k892hadronphotonBkg { for (int pIdx : photons1) { auto photon = fullV0s.rawIteratorAt(pIdx); float pP = std::hypot(photon.px(), photon.py(), photon.pz()); - ROOT::Math::PxPyPzEVector FourMomPhoton( + ROOT::Math::PxPyPzEVector fourMomPhoton( photon.px(), photon.py(), photon.pz(), pP); for (int kIdx : kshorts2) { auto kshort = fullV0s.rawIteratorAt(kIdx); float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); - ROOT::Math::PxPyPzEVector FourMomKShort( + ROOT::Math::PxPyPzEVector fourMomKShort( kshort.px(), kshort.py(), kshort.pz(), std::sqrt(kP * kP + o2::constants::physics::MassK0Short * o2::constants::physics::MassK0Short)); - auto FourMomKStar = FourMomPhoton + FourMomKShort; + auto fourMomKStar = fourMomPhoton + fourMomKShort; - double cosOA = FourMomPhoton.Vect().Dot(FourMomKShort.Vect()) / - (FourMomPhoton.P() * FourMomKShort.P()); + double cosOA = fourMomPhoton.Vect().Dot(fourMomKShort.Vect()) / + (fourMomPhoton.P() * fourMomKShort.P()); double openAngle = std::acos(cosOA); - float mass = FourMomKStar.M(); - float pt = FourMomKStar.Pt(); + float mass = fourMomKStar.M(); + float pt = fourMomKStar.Pt(); // Rapidity computed under the K*(892) mass hypothesis (NOT the actual pair // invariant mass) to match the same-event rotational background and the // buildKStar signal selection, so the rapidity acceptance is identical for // signal and all backgrounds. - float rapidity = RecoDecay::y(std::array{static_cast(FourMomKStar.Px()), - static_cast(FourMomKStar.Py()), - static_cast(FourMomKStar.Pz())}, + float rapidity = RecoDecay::y(std::array{static_cast(fourMomKStar.Px()), + static_cast(fourMomKStar.Py()), + static_cast(fourMomKStar.Pz())}, o2::constants::physics::MassK0Star892); if (openAngle > kstarBkgConfig.kstarMaxOPAngle) diff --git a/iwyu.out b/iwyu.out new file mode 100644 index 00000000000..1be61ec630a --- /dev/null +++ b/iwyu.out @@ -0,0 +1 @@ +iwyu_tool.py: command not found From eff0c58df77fe7db8f5341fbfdf221598ee1f256 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 19 Jun 2026 14:05:39 +0000 Subject: [PATCH 09/13] Please consider the following formatting changes --- PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index 9968918cf54..6fefc8ad0ad 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -36,13 +36,13 @@ #include #include #include +#include #include #include #include #include #include #include -#include "Framework/BinningPolicy.h" #include #include @@ -50,10 +50,10 @@ #include #include +#include #include #include #include -#include using namespace o2; using namespace o2::framework; From dc7f145c742b60b060b73ece5f13d3f1b5680ac9 Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Fri, 19 Jun 2026 16:10:44 +0200 Subject: [PATCH 10/13] accidentally added a dummy file --- iwyu.out | 1 - 1 file changed, 1 deletion(-) delete mode 100644 iwyu.out diff --git a/iwyu.out b/iwyu.out deleted file mode 100644 index 1be61ec630a..00000000000 --- a/iwyu.out +++ /dev/null @@ -1 +0,0 @@ -iwyu_tool.py: command not found From a88d7fedd52c3f63900b8b75b620486218a34302 Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Fri, 19 Jun 2026 17:07:06 +0200 Subject: [PATCH 11/13] Fixed: Use constant references for non-modified iterators in range-based for loops. --- PWGLF/Tasks/Resonances/k892hadronphoton.cxx | 20 +++++++------- .../Tasks/Resonances/k892hadronphotonBkg.cxx | 26 +++++++++---------- 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx index 7bebeae517c..6833059f0b6 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphoton.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphoton.cxx @@ -683,7 +683,7 @@ struct k892hadronphoton { fillGeneratedEventProperties(mcCollisions, collisions); std::vector listBestCollisionIdx = getListOfRecoCollIndices(mcCollisions, collisions); - for (auto& genParticle : genParticles) { + for (const auto& genParticle : genParticles) { float centrality = 100.5f; // Has MC collision @@ -802,10 +802,10 @@ struct k892hadronphoton { static constexpr std::string_view MainDir[] = {"BeforeSel", "AfterSel"}; bool fIsKStar = kstar.isKStar(); - int PhotonPDGCode = kstar.photonPDGCode(); - int PhotonPDGCodeMother = kstar.photonPDGCodeMother(); - int KShortPDGCode = kstar.kshortPDGCode(); - int KShortPDGCodeMother = kstar.kshortPDGCodeMother(); + int photonPDGCode = kstar.photonPDGCode(); + int photonPDGCodeMother = kstar.photonPDGCodeMother(); + int kshortPDGCode = kstar.kshortPDGCode(); + int kshortPDGCodeMother = kstar.kshortPDGCodeMother(); float kstarpT = kstar.pt(); float kstarMass = kstar.kstarMass(); @@ -813,24 +813,24 @@ struct k892hadronphoton { //_______________________________________ // Real Gamma x Real KShort - but not from the same kstar! - if ((!fIsKStar)) { //(std::abs(PhotonPDGCode) == PDG_t::kGamma) && (std::abs(KShortPDGCode) == PDG_t::kK0Short) && + if ((!fIsKStar)) { //(std::abs(photonPDGCode) == PDG_t::kGamma) && (std::abs(KShortPDGCode) == PDG_t::kK0Short) && histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_TrueDaughters"), kstarpT, kstarMass); - histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dTrueDaughtersMatrix"), KShortPDGCodeMother, PhotonPDGCodeMother); + histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dTrueDaughtersMatrix"), kshortPDGCodeMother, photonPDGCodeMother); } //_______________________________________ // Real Gamma x fake KShort - if ((std::abs(PhotonPDGCode) == PDG_t::kGamma) && (std::abs(KShortPDGCode) != PDG_t::kK0Short)) + if ((std::abs(photonPDGCode) == PDG_t::kGamma) && (std::abs(kshortPDGCode) != PDG_t::kK0Short)) histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_TrueGammaFakeKShort"), kstarpT, kstarMass); //_______________________________________ // Fake Gamma x Real KShort - if ((std::abs(PhotonPDGCode) != PDG_t::kGamma) && ((std::abs(KShortPDGCode) == PDG_t::kK0Short))) + if ((std::abs(photonPDGCode) != PDG_t::kGamma) && ((std::abs(kshortPDGCode) == PDG_t::kK0Short))) histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_FakeGammaTrueKShort"), kstarpT, kstarMass); //_______________________________________ // Fake Gamma x Fake KShort - if ((std::abs(PhotonPDGCode) != PDG_t::kGamma) && (std::abs(KShortPDGCode) != PDG_t::kK0Short)) + if ((std::abs(photonPDGCode) != PDG_t::kGamma) && (std::abs(kshortPDGCode) != PDG_t::kK0Short)) histos.fill(HIST(MainDir[mode]) + HIST("/MC/BkgStudy/h2dPtVsMassKStar_FakeDaughters"), kstarpT, kstarMass); } diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index 6fefc8ad0ad..6982d6024dc 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -534,11 +534,11 @@ struct k892hadronphotonBkg { return; const float centrality = doPPAnalysis ? coll.centFT0M() : coll.centFT0C(); - for (int kIdx : kshortIndices) { - auto kshort = fullV0s.rawIteratorAt(kIdx); + for (const int& kIdx : kshortIndices) { + const auto& kshort = fullV0s.rawIteratorAt(kIdx); - for (int pIdx : photonIndices) { - auto photon = fullV0s.rawIteratorAt(pIdx); + for (const int& pIdx : photonIndices) { + const auto& photon = fullV0s.rawIteratorAt(pIdx); // photon as a massless 4-vector ROOT::Math::PtEtaPhiMVector pGamma(photon.pt(), @@ -631,7 +631,7 @@ struct k892hadronphotonBkg { // the framework applies JSON overrides), silently ignoring user configuration. BkgBinningType bkgColBinning{{axisVertexMixBkg, axisCentralityMixBkg}, true}; - for (auto& [coll1, coll2] : selfCombinations(bkgColBinning, kstarBkgConfig.nMix, -1, + for (const auto& [coll1, coll2] : selfCombinations(bkgColBinning, kstarBkgConfig.nMix, -1, collisions, collisions)) { if (coll1.globalIndex() == coll2.globalIndex()) continue; @@ -651,8 +651,8 @@ struct k892hadronphotonBkg { // K0s(coll1) × γ(coll2) if (!kshorts1.empty() && !photons2.empty()) { - for (int kIdx : kshorts1) { - auto kshort = fullV0s.rawIteratorAt(kIdx); + for (const int& kIdx : kshorts1) { + const auto& kshort = fullV0s.rawIteratorAt(kIdx); float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); ROOT::Math::PxPyPzEVector fourMomKShort( kshort.px(), kshort.py(), kshort.pz(), @@ -660,8 +660,8 @@ struct k892hadronphotonBkg { o2::constants::physics::MassK0Short * o2::constants::physics::MassK0Short)); - for (int pIdx : photons2) { - auto photon = fullV0s.rawIteratorAt(pIdx); + for (const int& pIdx : photons2) { + const auto& photon = fullV0s.rawIteratorAt(pIdx); float pP = std::hypot(photon.px(), photon.py(), photon.pz()); ROOT::Math::PxPyPzEVector fourMomPhoton( photon.px(), photon.py(), photon.pz(), pP); @@ -698,14 +698,14 @@ struct k892hadronphotonBkg { // γ(coll1) × K0s(coll2) if (!photons1.empty() && !kshorts2.empty()) { - for (int pIdx : photons1) { - auto photon = fullV0s.rawIteratorAt(pIdx); + for (const int pIdx : photons1) { + const auto& photon = fullV0s.rawIteratorAt(pIdx); float pP = std::hypot(photon.px(), photon.py(), photon.pz()); ROOT::Math::PxPyPzEVector fourMomPhoton( photon.px(), photon.py(), photon.pz(), pP); - for (int kIdx : kshorts2) { - auto kshort = fullV0s.rawIteratorAt(kIdx); + for (const int kIdx : kshorts2) { + const auto& kshort = fullV0s.rawIteratorAt(kIdx); float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); ROOT::Math::PxPyPzEVector fourMomKShort( kshort.px(), kshort.py(), kshort.pz(), From b95cf106793236d32f958ca3caaadb29a037bbdf Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 19 Jun 2026 15:08:00 +0000 Subject: [PATCH 12/13] Please consider the following formatting changes --- PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index 6982d6024dc..af09ef9f13d 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -632,7 +632,7 @@ struct k892hadronphotonBkg { BkgBinningType bkgColBinning{{axisVertexMixBkg, axisCentralityMixBkg}, true}; for (const auto& [coll1, coll2] : selfCombinations(bkgColBinning, kstarBkgConfig.nMix, -1, - collisions, collisions)) { + collisions, collisions)) { if (coll1.globalIndex() == coll2.globalIndex()) continue; From 4798b868155431d2d856b398f9a88a9c52baa21f Mon Sep 17 00:00:00 2001 From: oussama3030 Date: Fri, 19 Jun 2026 17:11:54 +0200 Subject: [PATCH 13/13] fixed: Use constant references for non-modified iterators in range-based for loops. [const-ref-in-for-loop] --- PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx index af09ef9f13d..ee4411b2d37 100644 --- a/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx +++ b/PWGLF/Tasks/Resonances/k892hadronphotonBkg.cxx @@ -698,13 +698,13 @@ struct k892hadronphotonBkg { // γ(coll1) × K0s(coll2) if (!photons1.empty() && !kshorts2.empty()) { - for (const int pIdx : photons1) { + for (const int& pIdx : photons1) { const auto& photon = fullV0s.rawIteratorAt(pIdx); float pP = std::hypot(photon.px(), photon.py(), photon.pz()); ROOT::Math::PxPyPzEVector fourMomPhoton( photon.px(), photon.py(), photon.pz(), pP); - for (const int kIdx : kshorts2) { + for (const int& kIdx : kshorts2) { const auto& kshort = fullV0s.rawIteratorAt(kIdx); float kP = std::hypot(kshort.px(), kshort.py(), kshort.pz()); ROOT::Math::PxPyPzEVector fourMomKShort(