diff --git a/PWGEM/PhotonMeson/DataModel/gammaTables.h b/PWGEM/PhotonMeson/DataModel/gammaTables.h index 454bcea9740..1702cb054f6 100644 --- a/PWGEM/PhotonMeson/DataModel/gammaTables.h +++ b/PWGEM/PhotonMeson/DataModel/gammaTables.h @@ -72,6 +72,17 @@ DECLARE_SOA_TABLE(BinnedGenPts, "AOD", "BINNEDGENPT", // To be joined with EMMCE ); using BinnedGenPt = BinnedGenPts::iterator; +namespace emmcbinnedgendalitz +{ +DECLARE_SOA_COLUMN(GeneratedPi0Dalitz, generatedPi0Dalitz, std::vector); //! pi0 -> e+e-gamma binned generated data (pT, |y|, m_ee) +DECLARE_SOA_COLUMN(GeneratedEtaDalitz, generatedEtaDalitz, std::vector); //! eta -> e+e-gamma binned generated data (pT, |y|, m_ee) +} // namespace emmcbinnedgendalitz + +DECLARE_SOA_TABLE(BinnedGenDalitzs, "AOD", "BINNEDGENDAL", // To be joined with EMMCEvents table at analysis level. + emmcbinnedgendalitz::GeneratedPi0Dalitz, + emmcbinnedgendalitz::GeneratedEtaDalitz); +using BinnedGenDalitz = BinnedGenDalitzs::iterator; + // DECLARE_SOA_TABLE(BinnedGenPtAccs, "AOD", "BINNEDGENPTACC", // To be joined with EMMCEvents table at analysis level. // emmcbinnedgen::GeneratedPi0_Acc_gg, // emmcbinnedgen::GeneratedPi0_Acc_eeg, diff --git a/PWGEM/PhotonMeson/TableProducer/associateMCinfoPhoton.cxx b/PWGEM/PhotonMeson/TableProducer/associateMCinfoPhoton.cxx index 2d4051d2a47..240f337e2f4 100644 --- a/PWGEM/PhotonMeson/TableProducer/associateMCinfoPhoton.cxx +++ b/PWGEM/PhotonMeson/TableProducer/associateMCinfoPhoton.cxx @@ -16,6 +16,7 @@ #include "PWGEM/PhotonMeson/DataModel/EventTables.h" #include "PWGEM/PhotonMeson/DataModel/GammaTablesRedux.h" #include "PWGEM/PhotonMeson/DataModel/gammaTables.h" +#include "PWGEM/PhotonMeson/Utils/DalitzBinning.h" #include "PWGEM/PhotonMeson/Utils/MCUtilities.h" #include "Common/DataModel/EventSelection.h" @@ -34,6 +35,7 @@ #include #include +#include #include #include @@ -86,6 +88,7 @@ struct AssociateMCInfoPhoton { Produces ememcclustermclabels; Produces binnedGenPt; + Produces binnedGenDalitz; Configurable max_eta_gen_secondary{"max_eta_gen_secondary", 0.9, "max eta to store generated information"}; Configurable margin_z_gen{"margin_z_gen", 15.f, "margin for Z of true photon conversion point to store generated information"}; @@ -94,6 +97,7 @@ struct AssociateMCInfoPhoton { Configurable cfg_max_eta_photon{"cfg_max_eta_gamma", 0.8, "max eta for photons at PV"}; Configurable maxPt{"maxPt", 20.f, "max pT for BinnedGenPts table"}; Configurable maxY{"maxY", 0.9f, "max |rapidity| for BinnedGenPts table"}; + Configurable fillBinnedGenDalitz{"fillBinnedGenDalitz", false, "produce binned generated Dalitz decays and QA histograms"}; Configurable doStoreAllDaughters{"doStoreAllDaughters", false, "flag to enable storing of all photon, pi0, eta, eta' and omega daughters. This will increase the dervied data size!"}; Configurable useIsSelected{"useIsSelected", true, "flag to enable the usage of isSelected from our EM event selection. Disabling this will increase the derived data size!"}; Configurable useIsEOI{"useIsEOI", true, "flag to enable the usage of the EOI table"}; @@ -157,6 +161,18 @@ struct AssociateMCInfoPhoton { genGamma.resize(hBinFinder->GetNcells(), 0); genPi0.resize(hBinFinder->GetNcells(), 0); genEta.resize(hBinFinder->GetNcells(), 0); + + if (fillBinnedGenDalitz) { + namespace dalitzbinning = o2::aod::pwgem::photonmeson::utils::dalitzbinning; + const AxisSpec axisPtDalitz{dalitzbinning::ptBins(), "p_{T} (GeV/c)"}; + const AxisSpec axisYDalitz{dalitzbinning::yBins(), "rapidity |y|"}; + const AxisSpec axisMee{dalitzbinning::meeBins(), "m_{ee} (GeV/c^{2})"}; + registry.add("Generated/h3PtYMee_Pi0Dalitz", "Generated #pi^{0} #rightarrow e^{+}e^{-}#gamma", kTH3F, {axisPtDalitz, axisYDalitz, axisMee}, true); + registry.add("Generated/h3PtYMee_EtaDalitz", "Generated #eta #rightarrow e^{+}e^{-}#gamma", kTH3F, {axisPtDalitz, axisYDalitz, axisMee}, true); + const auto ncellsDalitz = registry.get(HIST("Generated/h3PtYMee_Pi0Dalitz"))->GetNcells(); + genPi0Dalitz.resize(ncellsDalitz, 0); + genEtaDalitz.resize(ncellsDalitz, 0); + } } Preslice perMcCollision = aod::mcparticle::mcCollisionId; @@ -165,10 +181,44 @@ struct AssociateMCInfoPhoton { Preslice perCollisionPHOS = aod::skimmedcluster::collisionId; Preslice perCollisionEMC = aod::skimmedcluster::collisionId; - std::vector genGamma; // primary, pt, y - std::vector genPi0; // primary, pt, y - std::vector genEta; // primary, pt, y + std::vector genGamma; // primary, pt, y + std::vector genPi0; // primary, pt, y + std::vector genEta; // primary, pt, y + std::vector genPi0Dalitz; // primary, pt, y, mee + std::vector genEtaDalitz; // primary, pt, y, mee + // invariant mass of the e+e- pair of a Dalitz decay (daughters: gamma, e+, e-); false for any other decay + template + bool getDalitzMee(TMCParticle const& mother, TMCParticles const& mcParticles, float& mee) + { + if (!mother.has_daughters()) { + return false; + } + int ngamma = 0, npos = 0, nele = 0; + float e = 0.f, px = 0.f, py = 0.f, pz = 0.f; + for (int id = mother.daughtersIds()[0]; id <= mother.daughtersIds()[1]; ++id) { + if (id < 0 || id >= mcParticles.size()) { + return false; + } + const auto d = mcParticles.rawIteratorAt(id); + if (d.pdgCode() == PDG_t::kGamma) { + ngamma++; + } else if (d.pdgCode() == PDG_t::kElectron || d.pdgCode() == PDG_t::kPositron) { + (d.pdgCode() == PDG_t::kElectron) ? nele++ : npos++; + e += d.e(); + px += d.px(); + py += d.py(); + pz += d.pz(); + } else { + return false; + } + } + if (ngamma != 1 || npos != 1 || nele != 1) { + return false; + } + mee = std::sqrt(std::max(0.f, e * e - px * px - py * py - pz * pz)); + return true; + } template void selectDaughtersToStore(TMCParticle& particle, int64_t mcParticleSize, TMCDaughter& daughterIter, int eventIdx, std::unordered_map& fNewLabels, std::map& fNewLabelsReversed, std::unordered_map& fEventIdx, Counter& fCounter) { @@ -361,6 +411,7 @@ struct AssociateMCInfoPhoton { std::unordered_map fEventLabels; Counter fCounter{.particles = 0, .events = 0}; //! [0] - particle counter, [1] - event counter auto hBinFinder = registry.get(HIST("Generated/h2PtY_Gamma")); + auto hBinFinderDalitz = fillBinnedGenDalitz ? registry.get(HIST("Generated/h3PtYMee_Pi0Dalitz")) : nullptr; // collision iterator from EMCal cluster auto collisionIter = collisions.begin(); @@ -417,7 +468,8 @@ struct AssociateMCInfoPhoton { std::fill(genGamma.begin(), genGamma.end(), 0); std::fill(genPi0.begin(), genPi0.end(), 0); std::fill(genEta.begin(), genEta.end(), 0); - + std::fill(genPi0Dalitz.begin(), genPi0Dalitz.end(), 0); + std::fill(genEtaDalitz.begin(), genEtaDalitz.end(), 0); mcCollisionIter.setCursor(collision.mcCollisionId()); // store mc particles auto groupedMcParticles = mcParticles.sliceBy(perMcCollision, mcCollisionIter.globalIndex()); @@ -440,6 +492,10 @@ struct AssociateMCInfoPhoton { genGamma[binNumber]++; break; case PDG_t::kPi0: + if (float meeDalitz = 0.f; fillBinnedGenDalitz && getDalitzMee(mcParticle, mcParticles, meeDalitz)) { + registry.fill(HIST("Generated/h3PtYMee_Pi0Dalitz"), mcParticle.pt(), std::fabs(mcParticle.y()), meeDalitz); + genPi0Dalitz[hBinFinderDalitz->FindBin(mcParticle.pt(), std::fabs(mcParticle.y()), meeDalitz)]++; + } if (requireGammaGammaDecay && !isGammaGammaDecay(mcParticle, mcParticles)) { continue; } @@ -450,6 +506,10 @@ struct AssociateMCInfoPhoton { } break; case Pdg::kEta: + if (float meeDalitz = 0.f; fillBinnedGenDalitz && getDalitzMee(mcParticle, mcParticles, meeDalitz)) { + registry.fill(HIST("Generated/h3PtYMee_EtaDalitz"), mcParticle.pt(), std::fabs(mcParticle.y()), meeDalitz); + genEtaDalitz[hBinFinderDalitz->FindBin(mcParticle.pt(), std::fabs(mcParticle.y()), meeDalitz)]++; + } if (requireGammaGammaDecay && !isGammaGammaDecay(mcParticle, mcParticles)) { continue; } @@ -474,6 +534,9 @@ struct AssociateMCInfoPhoton { fEventLabels[mcCollisionIter.globalIndex()] = fCounter.events; fCounter.events++; binnedGenPt(genGamma, genPi0, genEta); + if (fillBinnedGenDalitz) { + binnedGenDalitz(genPi0Dalitz, genEtaDalitz); + } } // LOGF(info, "collision.globalIndex() = %d , mceventlabels.lastIndex() = %d", collision.globalIndex(), mceventlabels.lastIndex()); diff --git a/PWGEM/PhotonMeson/Tasks/CMakeLists.txt b/PWGEM/PhotonMeson/Tasks/CMakeLists.txt index 850a578b3e4..ff57beada53 100644 --- a/PWGEM/PhotonMeson/Tasks/CMakeLists.txt +++ b/PWGEM/PhotonMeson/Tasks/CMakeLists.txt @@ -86,6 +86,11 @@ o2physics_add_dpl_workflow(pi0eta-to-gammagamma-pcmdalitzee PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::PWGEMPhotonMesonCore O2Physics::MLCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(pi0eta-meson-dalitz-form-factor + SOURCES Pi0EtaMesonDalitzFormFactor.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::PWGEMPhotonMesonCore O2Physics::MLCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(pi0eta-to-gammagamma-emcemc SOURCES Pi0EtaToGammaGammaEMCEMC.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2::EMCALBase O2::EMCALCalib O2Physics::AnalysisCore O2Physics::PWGEMPhotonMesonCore diff --git a/PWGEM/PhotonMeson/Tasks/Pi0EtaMesonDalitzFormFactor.cxx b/PWGEM/PhotonMeson/Tasks/Pi0EtaMesonDalitzFormFactor.cxx new file mode 100644 index 00000000000..de74a8b2ed7 --- /dev/null +++ b/PWGEM/PhotonMeson/Tasks/Pi0EtaMesonDalitzFormFactor.cxx @@ -0,0 +1,562 @@ +// 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. +// +/// \file Pi0EtaMesonDalitzFormFactor.cxx +/// \brief This code builds PCM-Dalitz (gamma + e+e-) candidates and fills a THnSparse of (pT, m(ee gamma), m(ee)) to measure the Dalitz form factor of pi0/eta. +/// \author Joshua Koenig (joshua.konig@cern.ch) + +#include "PWGEM/PhotonMeson/Core/DalitzEECut.h" +#include "PWGEM/PhotonMeson/Core/EMPhotonEventCut.h" +#include "PWGEM/PhotonMeson/Core/V0PhotonCut.h" +#include "PWGEM/PhotonMeson/DataModel/EventTables.h" +#include "PWGEM/PhotonMeson/DataModel/gammaTables.h" +#include "PWGEM/PhotonMeson/Utils/DalitzBinning.h" +#include "PWGEM/PhotonMeson/Utils/EMPhoton.h" +// Dilepton headers +#include "PWGEM/Dilepton/Utils/EventMixingHandler.h" +#include "PWGEM/Dilepton/Utils/MCUtilities.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include // IWYU pragma: keep (do not replace with Math/Vector4Dfwd.h) +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::aod; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::soa; + +enum class PairKind { + kSame, + kMix, + kTruePi0, // reconstructed, all three decay products from the same pi0 + kTrueEta // reconstructed, all three decay products from the same eta +}; + +struct Pi0EtaMesonDalitzFormFactor { + Configurable ccdburl{"ccdb-url", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; + Configurable d_bz_input{"d_bz_input", -999, "bz field in kG, -999 is automatic"}; + Configurable maxY{"maxY", 0.8, "maximum rapidity for reconstructed particles"}; + Configurable cfgRequireTrueAssociation{"cfgRequireTrueAssociation", false, "flag to require true mc collision association for validated mesons"}; + Configurable cfgDoMix{"cfgDoMix", true, "flag for event mixing"}; + Configurable ndepth{"ndepth", 10, "depth for event mixing"}; + Configurable ndiff_bc_mix{"ndiff_bc_mix", 594, "difference in global BC required in mixed events"}; + ConfigurableAxis ConfVtxBins{"ConfVtxBins", {VARIABLE_WIDTH, -10.0f, -8.f, -6.f, -4.f, -2.f, 0.f, 2.f, 4.f, 6.f, 8.f, 10.f}, "Mixing bins - z-vertex"}; + + ConfigurableAxis axisPt{"axisPt", {VARIABLE_WIDTH, 0.f, 0.5f, 1.f, 1.5f, 2.f, 2.5f, 3.f, 4.f, 5.f, 6.f, 8.f, 10.f, 20.f}, "pT of the meson candidate (GeV/c)"}; + ConfigurableAxis axisMmeson{"axisMmeson", {400, 0.f, 0.8f}, "m(ee#gamma) (GeV/c^{2})"}; + ConfigurableAxis axisMee{"axisMee", {VARIABLE_WIDTH, 0.f, 0.005f, 0.01f, 0.02f, 0.03f, 0.04f, 0.05f, 0.06f, 0.08f, 0.1f, 0.15f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f}, "m(ee) of the virtual photon (GeV/c^{2})"}; + + EMPhotonEventCut fEMEventCut; + struct : ConfigurableGroup { + std::string prefix = "eventcut_group"; + Configurable cfgZvtxMin{"cfgZvtxMin", -10.f, "min. Zvtx"}; + Configurable cfgZvtxMax{"cfgZvtxMax", +10.f, "max. Zvtx"}; + Configurable cfgRequireSel8{"cfgRequireSel8", true, "require sel8 in event cut"}; + Configurable cfgRequireFT0AND{"cfgRequireFT0AND", true, "require FT0AND in event cut"}; + Configurable cfgRequireNoTFB{"cfgRequireNoTFB", false, "require No time frame border in event cut"}; + Configurable cfgRequireNoITSROFB{"cfgRequireNoITSROFB", false, "require no ITS readout frame border in event cut"}; + Configurable cfgRequireNoSameBunchPileup{"cfgRequireNoSameBunchPileup", false, "require no same bunch pileup in event cut"}; + Configurable cfgRequireVertexITSTPC{"cfgRequireVertexITSTPC", false, "require Vertex ITSTPC in event cut"}; + Configurable cfgRequireGoodZvtxFT0vsPV{"cfgRequireGoodZvtxFT0vsPV", false, "require good Zvtx between FT0 vs. PV in event cut"}; + } eventcuts; + + V0PhotonCut fV0PhotonCut; + struct : ConfigurableGroup { + std::string prefix = "pcmcut_group"; + Configurable cfg_min_pt_v0{"cfg_min_pt_v0", 0.1, "min pT for v0 photons at PV"}; + Configurable cfg_max_pt_v0{"cfg_max_pt_v0", 1e+10, "max pT for v0 photons at PV"}; + Configurable cfg_min_eta_v0{"cfg_min_eta_v0", -0.8, "min eta for v0 photons at PV"}; + Configurable cfg_max_eta_v0{"cfg_max_eta_v0", 0.8, "max eta for v0 photons at PV"}; + Configurable cfg_min_v0radius{"cfg_min_v0radius", 4.0, "min v0 radius"}; + Configurable cfg_max_v0radius{"cfg_max_v0radius", 90.0, "max v0 radius"}; + Configurable cfg_max_alpha_ap{"cfg_max_alpha_ap", 0.95, "max alpha for AP cut"}; + Configurable cfg_max_qt_ap{"cfg_max_qt_ap", 0.01, "max qT for AP cut"}; + Configurable cfg_min_cospa{"cfg_min_cospa", 0.999, "min V0 CosPA"}; + Configurable cfg_max_pca{"cfg_max_pca", 1.5, "max distance btween 2 legs"}; + Configurable cfg_max_chi2kf{"cfg_max_chi2kf", 1e+10, "max chi2/ndf with KF"}; + Configurable cfg_reject_v0_on_itsib{"cfg_reject_v0_on_itsib", true, "flag to reject V0s on ITSib"}; + Configurable cfg_apply_cuts_from_prefilter_derived{"cfg_apply_cuts_from_prefilter_derived", false, "flag to apply prefilter to V0"}; + Configurable cfg_min_ncluster_tpc{"cfg_min_ncluster_tpc", 0, "min ncluster tpc"}; + Configurable cfg_min_ncrossedrows{"cfg_min_ncrossedrows", 40, "min ncrossed rows"}; + Configurable cfg_max_frac_shared_clusters_tpc{"cfg_max_frac_shared_clusters_tpc", 999.f, "max fraction of shared clusters in TPC"}; + Configurable cfg_max_chi2tpc{"cfg_max_chi2tpc", 4.0, "max chi2/NclsTPC"}; + Configurable cfg_max_chi2its{"cfg_max_chi2its", 36.0, "max chi2/NclsITS"}; + Configurable cfg_min_TPCNsigmaEl{"cfg_min_TPCNsigmaEl", -3.0, "min. TPC n sigma for electron"}; + Configurable cfg_max_TPCNsigmaEl{"cfg_max_TPCNsigmaEl", +3.0, "max. TPC n sigma for electron"}; + Configurable cfg_disable_itsonly_track{"cfg_disable_itsonly_track", false, "flag to disable ITSonly tracks"}; + Configurable cfg_disable_tpconly_track{"cfg_disable_tpconly_track", false, "flag to disable TPConly tracks"}; + } pcmcuts; + + DalitzEECut fDileptonCut; + struct : ConfigurableGroup { + std::string prefix = "dileptoncut_group"; + Configurable cfg_min_mass{"cfg_min_mass", 0.0, "min mass"}; + Configurable cfg_max_mass{"cfg_max_mass", 0.6, "max mass"}; + Configurable cfg_apply_phiv{"cfg_apply_phiv", true, "flag to apply phiv cut"}; + Configurable cfg_require_itsib_any{"cfg_require_itsib_any", false, "flag to require ITS ib any hits"}; + Configurable cfg_require_itsib_1st{"cfg_require_itsib_1st", true, "flag to require ITS ib 1st hit"}; + Configurable cfg_phiv_slope{"cfg_phiv_slope", 0.0185, "slope for m vs. phiv"}; + Configurable cfg_phiv_intercept{"cfg_phiv_intercept", -0.0280, "intercept for m vs. phiv"}; + + Configurable cfg_min_pt_track{"cfg_min_pt_track", 0.1, "min pT for single track"}; + Configurable cfg_max_eta_track{"cfg_max_eta_track", 0.8, "max eta for single track"}; + Configurable cfg_min_ncluster_tpc{"cfg_min_ncluster_tpc", 0, "min ncluster tpc"}; + Configurable cfg_min_ncluster_its{"cfg_min_ncluster_its", 5, "min ncluster its"}; + Configurable cfg_min_ncrossedrows{"cfg_min_ncrossedrows", 70, "min ncrossed rows"}; + Configurable cfg_max_chi2tpc{"cfg_max_chi2tpc", 4.0, "max chi2/NclsTPC"}; + Configurable cfg_max_chi2its{"cfg_max_chi2its", 36.0, "max chi2/NclsITS"}; + Configurable cfg_max_dcaxy{"cfg_max_dcaxy", 0.05, "max dca XY for single track in cm"}; + Configurable cfg_max_dcaz{"cfg_max_dcaz", 0.05, "max dca Z for single track in cm"}; + Configurable cfg_max_dca3dsigma_track{"cfg_max_dca3dsigma_track", 1.5, "max DCA 3D in sigma"}; + Configurable cfg_max_frac_shared_clusters_tpc{"cfg_max_frac_shared_clusters_tpc", 999.f, "max fraction of shared clusters in TPC"}; + Configurable cfg_apply_cuts_from_prefilter_derived{"cfg_apply_cuts_from_prefilter_derived", false, "flag to apply prefilter to electron"}; + + Configurable cfg_pid_scheme{"cfg_pid_scheme", static_cast(DalitzEECut::PIDSchemes::kTOFif), "pid scheme [kTOFif : 0, kTPConly : 1]"}; + Configurable cfg_min_TPCNsigmaEl{"cfg_min_TPCNsigmaEl", -2.0, "min. TPC n sigma for electron inclusion"}; + Configurable cfg_max_TPCNsigmaEl{"cfg_max_TPCNsigmaEl", +3.0, "max. TPC n sigma for electron inclusion"}; + Configurable cfg_min_TPCNsigmaPi{"cfg_min_TPCNsigmaPi", -0.0, "min. TPC n sigma for pion exclusion"}; + Configurable cfg_max_TPCNsigmaPi{"cfg_max_TPCNsigmaPi", +0.0, "max. TPC n sigma for pion exclusion"}; + Configurable cfg_min_TOFNsigmaEl{"cfg_min_TOFNsigmaEl", -3.0, "min. TOF n sigma for electron inclusion"}; + Configurable cfg_max_TOFNsigmaEl{"cfg_max_TOFNsigmaEl", +3.0, "max. TOF n sigma for electron inclusion"}; + } dileptoncuts; + + HistogramRegistry fRegistry{"output", {}, OutputObjHandlingPolicy::AnalysisObject, false, false}; + + using MyCollisions = Join; + using MyV0Photons = Filtered>; + using MyPrimaryElectrons = Filtered>; + + using MyMCCollisions = Join; + using MyMCV0Legs = Join; + using MyMCPrimaryElectrons = Filtered>; + + SliceCache cache; + Preslice perCollision_pcm = aod::v0photonkf::pmeventId; + Preslice perCollision_electron = aod::emprimaryelectronda::pmeventId; + Filter prefilter_pcm = ifnode(pcmcuts.cfg_apply_cuts_from_prefilter_derived.node(), o2::aod::v0photonkf::pfbderived == static_cast(0), true); + Filter prefilter_primaryelectron = ifnode(dileptoncuts.cfg_apply_cuts_from_prefilter_derived.node(), o2::aod::emprimaryelectron::pfbderived == static_cast(0), true); + + Partition positrons = o2::aod::emprimaryelectron::sign > static_cast(0) && dileptoncuts.cfg_min_pt_track < o2::aod::track::pt&& nabs(o2::aod::track::eta) < dileptoncuts.cfg_max_eta_track; + Partition electrons = o2::aod::emprimaryelectron::sign < static_cast(0) && dileptoncuts.cfg_min_pt_track < o2::aod::track::pt && nabs(o2::aod::track::eta) < dileptoncuts.cfg_max_eta_track; + + Partition positronsMC = o2::aod::emprimaryelectron::sign > static_cast(0) && dileptoncuts.cfg_min_pt_track < o2::aod::track::pt&& nabs(o2::aod::track::eta) < dileptoncuts.cfg_max_eta_track; + Partition electronsMC = o2::aod::emprimaryelectron::sign < static_cast(0) && dileptoncuts.cfg_min_pt_track < o2::aod::track::pt && nabs(o2::aod::track::eta) < dileptoncuts.cfg_max_eta_track; + + using EventKey = std::pair; // + o2::aod::pwgem::dilepton::utils::EventMixingHandler emhPhoton; + o2::aod::pwgem::dilepton::utils::EventMixingHandler emhDilepton; + std::map mapEventToGlobalBC; + std::vector zvtx_bin_edges; + int ndf = 0; + std::unique_ptr hGenBinning; // (pT, |y|, m_ee) binning of the generated data, see DalitzBinning.h + Service ccdb{}; + int mRunNumber = -1; + float d_bz = 0.f; + + void init(InitContext&) + { + const AxisSpec axPt{axisPt, "#it{p}_{T,ee#gamma} (GeV/#it{c})"}; + const AxisSpec axMmeson{axisMmeson, "#it{m}_{ee#gamma} (GeV/#it{c}^{2})"}; + const AxisSpec axMee{axisMee, "#it{m}_{ee} (GeV/#it{c}^{2})"}; + fRegistry.add("Pair/same/hFormFactor", "ee#gamma candidates;#it{p}_{T,ee#gamma};#it{m}_{ee#gamma};#it{m}_{ee}", HistType::kTHnSparseD, {axMmeson, axPt, axMee}, true); + if (doprocessAnalysis && cfgDoMix) { + fRegistry.addClone("Pair/same/", "Pair/mix/"); + fRegistry.add("Pair/mix/hDiffBC", "diff. global BC in mixed event;|BC_{current} - BC_{mixed}|", HistType::kTH1D, {{10001, -0.5, 10000.5}}, true); + } + if (doprocessAnalysisMC) { + fRegistry.addClone("Pair/same/", "Pair/true_pi0/"); + fRegistry.addClone("Pair/same/", "Pair/true_eta/"); + fRegistry.addClone("Pair/same/", "Gen/pi0/"); + fRegistry.addClone("Pair/same/", "Gen/eta/"); + + namespace dalitzbinning = o2::aod::pwgem::photonmeson::utils::dalitzbinning; + const auto ptBins = dalitzbinning::ptBins(); + const auto yBins = dalitzbinning::yBins(); + const auto meeBins = dalitzbinning::meeBins(); + hGenBinning = std::make_unique("hGenBinning", "binning of the generated Dalitz decays", ptBins.size() - 1, ptBins.data(), yBins.size() - 1, yBins.data(), meeBins.size() - 1, meeBins.data()); + } + + zvtx_bin_edges = std::vector(ConfVtxBins.value.begin(), ConfVtxBins.value.end()); + zvtx_bin_edges.erase(zvtx_bin_edges.begin()); + emhPhoton.SetNdepth(ndepth); + emhDilepton.SetNdepth(ndepth); + + DefineEMEventCut(); + DefinePCMCut(); + DefineDileptonCut(); + + mRunNumber = 0; + d_bz = 0.f; + ccdb->setURL(ccdburl); + ccdb->setCaching(true); + ccdb->setLocalObjectValidityChecking(); + ccdb->setFatalWhenNull(false); + } + + template + void initCCDB(TCollision const& collision) + { + if (mRunNumber == collision.runNumber()) { + return; + } + mRunNumber = collision.runNumber(); + + if (d_bz_input > -990) { // o2-linter: disable=magic-number (override value) + d_bz = d_bz_input; + o2::parameters::GRPMagField grpmag; + if (std::fabs(d_bz) > 1e-5) { // o2-linter: disable=magic-number (override value) + grpmag.setL3Current(30000.f / (d_bz / 5.0f)); // o2-linter: disable=magic-number (override value) + } + o2::base::Propagator::initFieldFromGRP(&grpmag); + } else { + auto* grpmag = ccdb->getForRun("GLO/Config/GRPMagField", collision.runNumber()); + if (grpmag == nullptr) { + LOGF(fatal, "Could not retrieve GRPMagField for run %d", collision.runNumber()); + } + d_bz = grpmag->getNominalL3Field(); + } + fV0PhotonCut.SetD_Bz(d_bz); + } + + void DefineEMEventCut() + { + fEMEventCut = EMPhotonEventCut("fEMEventCut", "fEMEventCut"); + fEMEventCut.SetRequireSel8(eventcuts.cfgRequireSel8); + fEMEventCut.SetRequireFT0AND(eventcuts.cfgRequireFT0AND); + fEMEventCut.SetZvtxRange(eventcuts.cfgZvtxMin, eventcuts.cfgZvtxMax); + fEMEventCut.SetRequireNoTFB(eventcuts.cfgRequireNoTFB); + fEMEventCut.SetRequireNoITSROFB(eventcuts.cfgRequireNoITSROFB); + fEMEventCut.SetRequireNoSameBunchPileup(eventcuts.cfgRequireNoSameBunchPileup); + fEMEventCut.SetRequireVertexITSTPC(eventcuts.cfgRequireVertexITSTPC); + fEMEventCut.SetRequireGoodZvtxFT0vsPV(eventcuts.cfgRequireGoodZvtxFT0vsPV); + } + + void DefinePCMCut() + { + fV0PhotonCut = V0PhotonCut("fV0PhotonCut", "fV0PhotonCut"); + + fV0PhotonCut.SetV0PtRange(pcmcuts.cfg_min_pt_v0, pcmcuts.cfg_max_pt_v0); + fV0PhotonCut.SetV0EtaRange(pcmcuts.cfg_min_eta_v0, pcmcuts.cfg_max_eta_v0); + fV0PhotonCut.SetMinCosPA(pcmcuts.cfg_min_cospa); + fV0PhotonCut.SetMaxPCA(pcmcuts.cfg_max_pca); + fV0PhotonCut.SetMaxChi2KF(pcmcuts.cfg_max_chi2kf); + fV0PhotonCut.SetRxyRange(pcmcuts.cfg_min_v0radius, pcmcuts.cfg_max_v0radius, -1.f, -1.f); + fV0PhotonCut.SetAPRange(pcmcuts.cfg_max_alpha_ap, pcmcuts.cfg_max_qt_ap); + fV0PhotonCut.RejectITSib(pcmcuts.cfg_reject_v0_on_itsib); + + fV0PhotonCut.SetMinNClustersTPC(pcmcuts.cfg_min_ncluster_tpc); + fV0PhotonCut.SetMinNCrossedRowsTPC(pcmcuts.cfg_min_ncrossedrows); + fV0PhotonCut.SetMinNCrossedRowsOverFindableClustersTPC(0.8); + fV0PhotonCut.SetMaxFracSharedClustersTPC(pcmcuts.cfg_max_frac_shared_clusters_tpc); + fV0PhotonCut.SetChi2PerClusterTPC(0.0, pcmcuts.cfg_max_chi2tpc); + fV0PhotonCut.SetTPCNsigmaElRange(pcmcuts.cfg_min_TPCNsigmaEl, pcmcuts.cfg_max_TPCNsigmaEl); + fV0PhotonCut.SetChi2PerClusterITS(-1e+10, pcmcuts.cfg_max_chi2its); + fV0PhotonCut.SetNClustersITS(0, 7); + fV0PhotonCut.SetMeanClusterSizeITSob(0.0, 16.0); + fV0PhotonCut.SetDisableITSonly(pcmcuts.cfg_disable_itsonly_track); + fV0PhotonCut.SetDisableTPConly(pcmcuts.cfg_disable_tpconly_track); + } + + void DefineDileptonCut() + { + fDileptonCut = DalitzEECut("fDileptonCut", "fDileptonCut"); + + fDileptonCut.SetMeeRange(dileptoncuts.cfg_min_mass, dileptoncuts.cfg_max_mass); + fDileptonCut.SetMaxPhivPairMeeDep([&](float mll) { return (mll - dileptoncuts.cfg_phiv_intercept) / dileptoncuts.cfg_phiv_slope; }); + fDileptonCut.ApplyPhiV(dileptoncuts.cfg_apply_phiv); + fDileptonCut.RequireITSibAny(dileptoncuts.cfg_require_itsib_any); + fDileptonCut.RequireITSib1st(dileptoncuts.cfg_require_itsib_1st); + + fDileptonCut.SetTrackPtRange(dileptoncuts.cfg_min_pt_track, 1e+10f); + fDileptonCut.SetTrackEtaRange(-dileptoncuts.cfg_max_eta_track, +dileptoncuts.cfg_max_eta_track); + fDileptonCut.SetMinNClustersTPC(dileptoncuts.cfg_min_ncluster_tpc); + fDileptonCut.SetMinNCrossedRowsTPC(dileptoncuts.cfg_min_ncrossedrows); + fDileptonCut.SetMinNCrossedRowsOverFindableClustersTPC(0.8); + fDileptonCut.SetMaxFracSharedClustersTPC(dileptoncuts.cfg_max_frac_shared_clusters_tpc); + fDileptonCut.SetChi2PerClusterTPC(0.0, dileptoncuts.cfg_max_chi2tpc); + fDileptonCut.SetChi2PerClusterITS(0.0, dileptoncuts.cfg_max_chi2its); + fDileptonCut.SetNClustersITS(dileptoncuts.cfg_min_ncluster_its, 7); + fDileptonCut.SetMaxDcaXY(dileptoncuts.cfg_max_dcaxy); + fDileptonCut.SetMaxDcaZ(dileptoncuts.cfg_max_dcaz); + fDileptonCut.SetTrackDca3DRange(0.f, dileptoncuts.cfg_max_dca3dsigma_track); // in sigma + + fDileptonCut.SetPIDScheme(dileptoncuts.cfg_pid_scheme); + fDileptonCut.SetTPCNsigmaElRange(dileptoncuts.cfg_min_TPCNsigmaEl, dileptoncuts.cfg_max_TPCNsigmaEl); + fDileptonCut.SetTPCNsigmaPiRange(dileptoncuts.cfg_min_TPCNsigmaPi, dileptoncuts.cfg_max_TPCNsigmaPi); + fDileptonCut.SetTOFNsigmaElRange(dileptoncuts.cfg_min_TOFNsigmaEl, dileptoncuts.cfg_max_TOFNsigmaEl); + } + + /// \brief common pairing step (data, mixed, MC true): applies the rapidity cut and fills the sparse + template + bool fillPair(ROOT::Math::PtEtaPhiMVector const& v_gamma, ROOT::Math::PtEtaPhiMVector const& v_ee) + { + ROOT::Math::PtEtaPhiMVector v_eeg = v_gamma + v_ee; + if (std::fabs(v_eeg.Rapidity()) > maxY) { + return false; + } + if constexpr (kind == PairKind::kSame) { + fRegistry.fill(HIST("Pair/same/hFormFactor"), v_eeg.M(), v_eeg.Pt(), v_ee.M()); + } else if constexpr (kind == PairKind::kMix) { + fRegistry.fill(HIST("Pair/mix/hFormFactor"), v_eeg.M(), v_eeg.Pt(), v_ee.M()); + } else if constexpr (kind == PairKind::kTruePi0) { + fRegistry.fill(HIST("Pair/true_pi0/hFormFactor"), v_eeg.M(), v_eeg.Pt(), v_ee.M()); + } else if constexpr (kind == PairKind::kTrueEta) { + fRegistry.fill(HIST("Pair/true_eta/hFormFactor"), v_eeg.M(), v_eeg.Pt(), v_ee.M()); + } + return true; + } + + static ROOT::Math::PtEtaPhiMVector toVector(o2::aod::pwgem::photonmeson::utils::EMPhoton const& p) + { + return {p.pt(), p.eta(), p.phi(), p.mass()}; + } + + /// \brief pairs photons of the current event with dileptons from pooled events, and vice versa + template + void runMixing(TCollision const& collision, int zbin, EventKey const& key_df_collision) + { + const auto& photons_this = emhPhoton.GetTracksPerCollision(key_df_collision); + const auto& dileptons_this = emhDilepton.GetTracksPerCollision(key_df_collision); + + for (const auto& key_mix : emhPhoton.GetCollisionIdsFromEventPool(zbin)) { + if (key_mix == key_df_collision) { + continue; + } + const uint64_t globalBC_mix = mapEventToGlobalBC[key_mix]; + const uint64_t diffBC = std::max(collision.globalBC(), globalBC_mix) - std::min(collision.globalBC(), globalBC_mix); + fRegistry.fill(HIST("Pair/mix/hDiffBC"), diffBC); + if (diffBC < ndiff_bc_mix) { + continue; + } + + for (const auto& g : photons_this) { + for (const auto& ee : emhDilepton.GetTracksPerCollision(key_mix)) { + fillPair(toVector(g), toVector(ee)); + } + } + for (const auto& ee : dileptons_this) { + for (const auto& g : emhPhoton.GetTracksPerCollision(key_mix)) { + fillPair(toVector(g), toVector(ee)); + } + } + } + } + + void processAnalysis(MyCollisions const& collisions, MyV0Photons const& v0photons, aod::V0Legs const&, MyPrimaryElectrons const&) + { + for (const auto& collision : collisions) { + initCCDB(collision); + if (!fEMEventCut.IsSelected(collision)) { + continue; + } + + int zbin = std::lower_bound(zvtx_bin_edges.begin(), zvtx_bin_edges.end(), collision.posZ()) - zvtx_bin_edges.begin() - 1; + zbin = std::clamp(zbin, 0, static_cast(zvtx_bin_edges.size()) - 2); + const EventKey key_df_collision{ndf, collision.globalIndex()}; + std::vector used_photonIds; + std::vector> used_dileptonIds; + int npair = 0; + + auto photons_per_collision = v0photons.sliceBy(perCollision_pcm, collision.globalIndex()); + auto positrons_per_collision = positrons->sliceByCached(aod::emprimaryelectronda::pmeventId, collision.globalIndex(), cache); + auto electrons_per_collision = electrons->sliceByCached(aod::emprimaryelectronda::pmeventId, collision.globalIndex(), cache); + + for (const auto& g1 : photons_per_collision) { + if (!fV0PhotonCut.IsSelected(g1)) { + continue; + } + auto pos1 = g1.template posTrack_as(); + auto ele1 = g1.template negTrack_as(); + ROOT::Math::PtEtaPhiMVector v_gamma(g1.pt(), g1.eta(), g1.phi(), 0.); + + for (const auto& [pos2, ele2] : combinations(CombinationsFullIndexPolicy(positrons_per_collision, electrons_per_collision))) { + if (pos2.trackId() == ele2.trackId()) { // protection against pairing identical tracks + continue; + } + if (pos1.trackId() == pos2.trackId() || ele1.trackId() == ele2.trackId()) { // electrons already used by the PCM photon + continue; + } + if (!fDileptonCut.IsSelected(pos2, ele2, d_bz)) { + continue; + } + + ROOT::Math::PtEtaPhiMVector v_pos(pos2.pt(), pos2.eta(), pos2.phi(), o2::constants::physics::MassElectron); + ROOT::Math::PtEtaPhiMVector v_ele(ele2.pt(), ele2.eta(), ele2.phi(), o2::constants::physics::MassElectron); + ROOT::Math::PtEtaPhiMVector v_ee = v_pos + v_ele; + if (!fillPair(v_gamma, v_ee)) { + continue; + } + npair++; + + if (!cfgDoMix) { + continue; + } + if (std::find(used_photonIds.begin(), used_photonIds.end(), g1.globalIndex()) == used_photonIds.end()) { + emhPhoton.AddTrackToEventPool(key_df_collision, o2::aod::pwgem::photonmeson::utils::EMPhoton(g1.pt(), g1.eta(), g1.phi(), 0.f)); + used_photonIds.emplace_back(g1.globalIndex()); + } + const std::pair ids_ee{pos2.trackId(), ele2.trackId()}; + if (std::find(used_dileptonIds.begin(), used_dileptonIds.end(), ids_ee) == used_dileptonIds.end()) { + emhDilepton.AddTrackToEventPool(key_df_collision, o2::aod::pwgem::photonmeson::utils::EMPhoton(v_ee.Pt(), v_ee.Eta(), v_ee.Phi(), v_ee.M())); + used_dileptonIds.emplace_back(ids_ee); + } + } // end of dielectron loop + } // end of photon loop + + if (!cfgDoMix || npair == 0) { + continue; + } + runMixing(collision, zbin, key_df_collision); + + emhPhoton.AddCollisionIdAtLast(zbin, key_df_collision); + if (auto evicted = emhDilepton.AddCollisionIdAtLast(zbin, key_df_collision)) { + mapEventToGlobalBC.erase(*evicted); + } + mapEventToGlobalBC[key_df_collision] = collision.globalBC(); + } // end of collision loop + ndf++; + } + PROCESS_SWITCH(Pi0EtaMesonDalitzFormFactor, processAnalysis, "process ee-gamma pair analysis", true); + + /// \brief fills the generated pi0/eta -> e+ e- gamma distributions from the binned data of the MC event + template + void fillBinnedGen(TBinnedData const& binned_data, const float mass) + { + int xbin = 0, ybin = 0, zbin = 0; + for (int ibin = 0; ibin < hGenBinning->GetNcells(); ibin++) { + const int nentry = binned_data[ibin]; + if (nentry == 0) { + continue; + } + if (hGenBinning->IsBinUnderflow(ibin) || hGenBinning->IsBinOverflow(ibin)) { + continue; + } + hGenBinning->GetBinXYZ(ibin, xbin, ybin, zbin); + if (hGenBinning->GetYaxis()->GetBinCenter(ybin) > maxY) { + continue; + } + const double pt = hGenBinning->GetXaxis()->GetBinCenter(xbin); + const double mee = hGenBinning->GetZaxis()->GetBinCenter(zbin); + if constexpr (isPi0) { + fRegistry.fill(HIST("Gen/pi0/hFormFactor"), mass, pt, mee, static_cast(nentry)); + } else { + fRegistry.fill(HIST("Gen/eta/hFormFactor"), mass, pt, mee, static_cast(nentry)); + } + } + } + + void processAnalysisMC(MyMCCollisions const& collisions, MyV0Photons const& v0photons, MyMCV0Legs const&, MyMCPrimaryElectrons const&, Join const&, aod::EMMCParticles const& mcparticles) + { + for (const auto& collision : collisions) { + initCCDB(collision); + if (!fEMEventCut.IsSelected(collision)) { + continue; + } + + auto mccollision = collision.template emmcevent_as>(); + fillBinnedGen(mccollision.generatedPi0Dalitz(), o2::constants::physics::MassPionNeutral); + fillBinnedGen(mccollision.generatedEtaDalitz(), o2::constants::physics::MassEta); + + auto photons_per_collision = v0photons.sliceBy(perCollision_pcm, collision.globalIndex()); + auto positrons_per_collision = positronsMC->sliceByCached(aod::emprimaryelectronda::pmeventId, collision.globalIndex(), cache); + auto electrons_per_collision = electronsMC->sliceByCached(aod::emprimaryelectronda::pmeventId, collision.globalIndex(), cache); + + for (const auto& g1 : photons_per_collision) { + if (!fV0PhotonCut.IsSelected(g1)) { + continue; + } + auto pos1 = g1.template posTrack_as(); + auto ele1 = g1.template negTrack_as(); + auto pos1mc = pos1.template emmcparticle_as(); + auto ele1mc = ele1.template emmcparticle_as(); + const int photonid = o2::aod::pwgem::dilepton::utils::mcutil::FindCommonMotherFrom2Prongs(pos1mc, ele1mc, -11, 11, 22, mcparticles); + if (photonid < 0) { + continue; + } + auto g1mc = mcparticles.iteratorAt(photonid); + ROOT::Math::PtEtaPhiMVector v_gamma(g1.pt(), g1.eta(), g1.phi(), 0.); + + for (const auto& [pos2, ele2] : combinations(CombinationsFullIndexPolicy(positrons_per_collision, electrons_per_collision))) { + if (pos2.trackId() == ele2.trackId()) { // protection against pairing identical tracks + continue; + } + if (pos1.trackId() == pos2.trackId() || ele1.trackId() == ele2.trackId()) { // electrons already used by the PCM photon + continue; + } + if (!fDileptonCut.IsSelected(pos2, ele2, d_bz)) { + continue; + } + + auto pos2mc = mcparticles.iteratorAt(pos2.emmcparticleId()); + auto ele2mc = mcparticles.iteratorAt(ele2.emmcparticleId()); + const int pi0id = o2::aod::pwgem::dilepton::utils::mcutil::FindCommonMotherFrom3Prongs(g1mc, pos2mc, ele2mc, 22, -11, 11, 111, mcparticles); + const int etaid = o2::aod::pwgem::dilepton::utils::mcutil::FindCommonMotherFrom3Prongs(g1mc, pos2mc, ele2mc, 22, -11, 11, 221, mcparticles); + if (pi0id < 0 && etaid < 0) { + continue; + } + + ROOT::Math::PtEtaPhiMVector v_pos(pos2.pt(), pos2.eta(), pos2.phi(), o2::constants::physics::MassElectron); + ROOT::Math::PtEtaPhiMVector v_ele(ele2.pt(), ele2.eta(), ele2.phi(), o2::constants::physics::MassElectron); + ROOT::Math::PtEtaPhiMVector v_ee = v_pos + v_ele; + + if (pi0id > 0) { + if (cfgRequireTrueAssociation && mcparticles.iteratorAt(pi0id).emmceventId() != collision.emmceventId()) { + continue; + } + fillPair(v_gamma, v_ee); + } else { + if (cfgRequireTrueAssociation && mcparticles.iteratorAt(etaid).emmceventId() != collision.emmceventId()) { + continue; + } + fillPair(v_gamma, v_ee); + } + } // end of dielectron loop + } // end of photon loop + } // end of collision loop + } + PROCESS_SWITCH(Pi0EtaMesonDalitzFormFactor, processAnalysisMC, "process ee-gamma pairs with MC truth (true and generated mesons)", false); + + void processDummy(aod::PMEvents const&) {} + PROCESS_SWITCH(Pi0EtaMesonDalitzFormFactor, processDummy, "Dummy function", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& context) +{ + return WorkflowSpec{ + adaptAnalysisTask(context)}; +} diff --git a/PWGEM/PhotonMeson/Utils/DalitzBinning.h b/PWGEM/PhotonMeson/Utils/DalitzBinning.h new file mode 100644 index 00000000000..49217767ee2 --- /dev/null +++ b/PWGEM/PhotonMeson/Utils/DalitzBinning.h @@ -0,0 +1,58 @@ +// 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. +// +/// \file DalitzBinning.h +/// \brief Binning of the generated pi0/eta Dalitz decays (pT, |y|, m_ee) shared by the producer and the analysis. Both sides must use these bins. +/// \author Joshua Koenig (joshua.konig@cern.ch) + +#ifndef PWGEM_PHOTONMESON_UTILS_DALITZBINNING_H_ +#define PWGEM_PHOTONMESON_UTILS_DALITZBINNING_H_ + +#include + +namespace o2::aod::pwgem::photonmeson::utils::dalitzbinning +{ +inline std::vector ptBins() +{ + std::vector bins; + bins.reserve(34); + for (int i = 0; i < 16; i++) { // o2-linter: disable=magic-number (just numbers for binning) + bins.emplace_back(0.25 * i); // 0 to 3.75 GeV/c, every 0.25 GeV/c + } + for (int i = 0; i < 12; i++) { // o2-linter: disable=magic-number (just numbers for binning) + bins.emplace_back(4.0 + 0.5 * i); // 4 to 9.5 GeV/c, every 0.5 GeV/c + } + for (int i = 0; i < 6; i++) { // o2-linter: disable=magic-number (just numbers for binning) + bins.emplace_back(10.0 + 2.0 * i); // 10 to 20 GeV/c, every 2 GeV/c + } + return bins; +} + +inline std::vector yBins() +{ + return {0.0, 0.8, 0.9}; +} + +inline std::vector meeBins() +{ + std::vector bins; + bins.reserve(46); + for (int i = 0; i < 20; i++) { // o2-linter: disable=magic-number (just numbers for binning) + bins.emplace_back(0.005 * i); // 0 to 0.095 GeV/c^2, every 0.005 GeV/c^2 + } + for (int i = 0; i < 26; i++) { // o2-linter: disable=magic-number (just numbers for binning) + bins.emplace_back(0.1 + 0.02 * i); // 0.1 to 0.6 GeV/c^2, every 0.02 GeV/c^2 + } + return bins; +} +} // namespace o2::aod::pwgem::photonmeson::utils::dalitzbinning + +#endif // PWGEM_PHOTONMESON_UTILS_DALITZBINNING_H_